/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.3.1
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


#define SWIG_VERSION 0x040301
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_LibreDWG"
/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

#if defined(SWIGPYTHON_BUILTIN) && defined(SWIG_HEAPTYPES)
/* SWIG_HEAPTYPES is not ready for use with SWIGPYTHON_BUILTIN, but if turned on manually requires the following */
#if PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows returning the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporary objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

#ifdef Py_LIMITED_API
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  case SWIG_NullReferenceError:
    type = PyExc_TypeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, traceback);
    }
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  SWIG_Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
}

#endif

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module() {
  if (!Swig_runtime_data_module_global) {
#if PY_VERSION_HEX >= 0x03000000
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
#else
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table);
#endif
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
  }
  return Swig_runtime_data_module_global;
}

/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000
#define SWIG_HEAPTYPES
#endif

SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_doc,                    /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data)
{
  SWIG_Py_XDECREF(data->klass);
  SWIG_Py_XDECREF(data->newraw);
  SWIG_Py_XDECREF(data->newargs);
  SWIG_Py_XDECREF(data->destroy);
  free(data);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  SWIG_Py_XINCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
        res = PyUnicode_Format(ofmt,args);
#else
        res = PyString_Format(ofmt,args);
#endif
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_Py_DECREF(args);
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  return repr;
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    if (op != Py_EQ && op != Py_NE) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  if (PyType_IsSubtype(op_type, target_tp))
    return 1;
  return (strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0);
#else
# ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  if (op_type == target_tp)
    return 1;
# ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
# else
  return (strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0);
# endif
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

static PyObject* Swig_Capsule_global = NULL;

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      SWIG_Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
  SWIG_Py_XDECREF(sobj->dict);
#endif
  PyObject_Free(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
SwigPyObject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyObject",  /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_methods,                 /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
#ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  PyTypeObject* op_type = Py_TYPE(op);
  if (op_type == SwigPyPacked_type())
    return 1;
#ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
#else
  return (strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0);
#endif
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_Free(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyPacked",  /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyPacked_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_Free((PyObject *)sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    PyWeakref_GetRef(pyobj, &pyobj);
    Py_DECREF(pyobj);
#else
    pyobj = PyWeakref_GET_OBJECT(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 0;
      }
      res = SWIG_OK;
    }
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            SWIG_Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      if (newobj) {
        newobj->dict = 0;
      }
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    SWIG_Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  }
#else
  void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
  if (PyErr_Occurred()) {
    PyErr_Clear();
    type_pointer = (void *)0;
  }
#endif
  return (swig_module_info *) type_pointer;
}


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i = 0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_Py_XDECREF(Swig_This_global);
  SWIG_PYOBJ_REFCNT(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_Py_XDECREF(Swig_Globals_global);
  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_Py_XDECREF(Swig_TypeCache_global);
  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) {
        PyDict_SetItem(cache, key, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  SWIG_Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  (void) obj;
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
#ifndef Py_LIMITED_API
      /* tp_name is not accessible */
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	PyObject *bytes = NULL;
	const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	SWIG_Py_XDECREF(bytes);
	SWIG_Py_XDECREF(str);
	return;
      }
#endif
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) != 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_DWG_CLASS_STABILITY swig_types[0]
#define SWIGTYPE_p_DWG_COLOR_METHOD swig_types[1]
#define SWIGTYPE_p_DWG_ENTITY_SECTIONS swig_types[2]
#define SWIGTYPE_p_DWG_ERROR swig_types[3]
#define SWIGTYPE_p_DWG_HDL_CODE swig_types[4]
#define SWIGTYPE_p_DWG_OBJECT_SUPERTYPE swig_types[5]
#define SWIGTYPE_p_DWG_OBJECT_TYPE swig_types[6]
#define SWIGTYPE_p_DWG_OBJECT_TYPE_R11 swig_types[7]
#define SWIGTYPE_p_DWG_SECTION_TYPE swig_types[8]
#define SWIGTYPE_p_DWG_SECTION_TYPE_R11 swig_types[9]
#define SWIGTYPE_p_DWG_SECTION_TYPE_R13 swig_types[10]
#define SWIGTYPE_p_DWG_VERSION_TYPE swig_types[11]
#define SWIGTYPE_p_Dwg_Section_Info swig_types[12]
#define SWIGTYPE_p_Dwg_Section_InfoHdr swig_types[13]
#define SWIGTYPE_p_RESBUF_VALUE_TYPE swig_types[14]
#define SWIGTYPE_p__dwg_3DSOLID_material swig_types[15]
#define SWIGTYPE_p__dwg_3DSOLID_silhouette swig_types[16]
#define SWIGTYPE_p__dwg_3DSOLID_wire swig_types[17]
#define SWIGTYPE_p__dwg_ACSH_HistoryNode swig_types[18]
#define SWIGTYPE_p__dwg_ACSH_SubentColor swig_types[19]
#define SWIGTYPE_p__dwg_ACSH_SubentMaterial swig_types[20]
#define SWIGTYPE_p__dwg_ACTIONBODY swig_types[21]
#define SWIGTYPE_p__dwg_ARRAYITEMLOCATOR swig_types[22]
#define SWIGTYPE_p__dwg_ASSOCACTIONBODY_action swig_types[23]
#define SWIGTYPE_p__dwg_ASSOCACTION_Deps swig_types[24]
#define SWIGTYPE_p__dwg_ASSOCARRAYITEM swig_types[25]
#define SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY swig_types[26]
#define SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY swig_types[27]
#define SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded swig_types[28]
#define SWIGTYPE_p__dwg_AcDs swig_types[29]
#define SWIGTYPE_p__dwg_AcDs_Data swig_types[30]
#define SWIGTYPE_p__dwg_AcDs_DataBlob swig_types[31]
#define SWIGTYPE_p__dwg_AcDs_DataBlob01 swig_types[32]
#define SWIGTYPE_p__dwg_AcDs_DataBlobRef swig_types[33]
#define SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page swig_types[34]
#define SWIGTYPE_p__dwg_AcDs_DataIndex swig_types[35]
#define SWIGTYPE_p__dwg_AcDs_DataIndex_Entry swig_types[36]
#define SWIGTYPE_p__dwg_AcDs_Data_Record swig_types[37]
#define SWIGTYPE_p__dwg_AcDs_Data_RecordHdr swig_types[38]
#define SWIGTYPE_p__dwg_AcDs_Schema swig_types[39]
#define SWIGTYPE_p__dwg_AcDs_SchemaData swig_types[40]
#define SWIGTYPE_p__dwg_AcDs_SchemaData_UProp swig_types[41]
#define SWIGTYPE_p__dwg_AcDs_SchemaIndex swig_types[42]
#define SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop swig_types[43]
#define SWIGTYPE_p__dwg_AcDs_Schema_Prop swig_types[44]
#define SWIGTYPE_p__dwg_AcDs_Search swig_types[45]
#define SWIGTYPE_p__dwg_AcDs_Search_Data swig_types[46]
#define SWIGTYPE_p__dwg_AcDs_Search_IdIdx swig_types[47]
#define SWIGTYPE_p__dwg_AcDs_Search_IdIdxs swig_types[48]
#define SWIGTYPE_p__dwg_AcDs_Segment swig_types[49]
#define SWIGTYPE_p__dwg_AcDs_SegmentIndex swig_types[50]
#define SWIGTYPE_p__dwg_BLOCKACTION_connectionpts swig_types[51]
#define SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut swig_types[52]
#define SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo swig_types[53]
#define SWIGTYPE_p__dwg_BLOCKPARAMETER_connection swig_types[54]
#define SWIGTYPE_p__dwg_BLOCKPARAMVALUESET swig_types[55]
#define SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes swig_types[56]
#define SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles swig_types[57]
#define SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state swig_types[58]
#define SWIGTYPE_p__dwg_COMPOUNDOBJECTID swig_types[59]
#define SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE swig_types[60]
#define SWIGTYPE_p__dwg_CONTEXTDATA_dict swig_types[61]
#define SWIGTYPE_p__dwg_CONTEXTDATA_submgr swig_types[62]
#define SWIGTYPE_p__dwg_CellContentGeometry swig_types[63]
#define SWIGTYPE_p__dwg_CellStyle swig_types[64]
#define SWIGTYPE_p__dwg_ColorRamp swig_types[65]
#define SWIGTYPE_p__dwg_ContentFormat swig_types[66]
#define SWIGTYPE_p__dwg_DATALINK_customdata swig_types[67]
#define SWIGTYPE_p__dwg_DATATABLE_column swig_types[68]
#define SWIGTYPE_p__dwg_DATATABLE_row swig_types[69]
#define SWIGTYPE_p__dwg_DIMASSOC_Ref swig_types[70]
#define SWIGTYPE_p__dwg_DIMENSION_common swig_types[71]
#define SWIGTYPE_p__dwg_EVAL_Edge swig_types[72]
#define SWIGTYPE_p__dwg_EVAL_Node swig_types[73]
#define SWIGTYPE_p__dwg_EvalExpr swig_types[74]
#define SWIGTYPE_p__dwg_EvalExpr_value swig_types[75]
#define SWIGTYPE_p__dwg_EvalVariant swig_types[76]
#define SWIGTYPE_p__dwg_EvalVariant_u swig_types[77]
#define SWIGTYPE_p__dwg_FIELD_ChildValue swig_types[78]
#define SWIGTYPE_p__dwg_FileDepList_Files swig_types[79]
#define SWIGTYPE_p__dwg_FormattedTableData swig_types[80]
#define SWIGTYPE_p__dwg_FormattedTableMerged swig_types[81]
#define SWIGTYPE_p__dwg_GEODATA_meshface swig_types[82]
#define SWIGTYPE_p__dwg_GEODATA_meshpt swig_types[83]
#define SWIGTYPE_p__dwg_GridFormat swig_types[84]
#define SWIGTYPE_p__dwg_HATCH_Color swig_types[85]
#define SWIGTYPE_p__dwg_HATCH_ControlPoint swig_types[86]
#define SWIGTYPE_p__dwg_HATCH_DefLine swig_types[87]
#define SWIGTYPE_p__dwg_HATCH_Path swig_types[88]
#define SWIGTYPE_p__dwg_HATCH_PathSeg swig_types[89]
#define SWIGTYPE_p__dwg_HATCH_PolylinePath swig_types[90]
#define SWIGTYPE_p__dwg_LAYER_entry swig_types[91]
#define SWIGTYPE_p__dwg_LEADER_ArrowHead swig_types[92]
#define SWIGTYPE_p__dwg_LEADER_BlockLabel swig_types[93]
#define SWIGTYPE_p__dwg_LEADER_Break swig_types[94]
#define SWIGTYPE_p__dwg_LEADER_Line swig_types[95]
#define SWIGTYPE_p__dwg_LEADER_Node swig_types[96]
#define SWIGTYPE_p__dwg_LIGHTLIST_light swig_types[97]
#define SWIGTYPE_p__dwg_LTYPE_dash swig_types[98]
#define SWIGTYPE_p__dwg_LWPOLYLINE_width swig_types[99]
#define SWIGTYPE_p__dwg_LinkedData swig_types[100]
#define SWIGTYPE_p__dwg_LinkedTableData swig_types[101]
#define SWIGTYPE_p__dwg_MATERIAL_color swig_types[102]
#define SWIGTYPE_p__dwg_MATERIAL_gentexture swig_types[103]
#define SWIGTYPE_p__dwg_MATERIAL_mapper swig_types[104]
#define SWIGTYPE_p__dwg_MESH_edge swig_types[105]
#define SWIGTYPE_p__dwg_MLEADER_AnnotContext swig_types[106]
#define SWIGTYPE_p__dwg_MLEADER_Content swig_types[107]
#define SWIGTYPE_p__dwg_MLEADER_Content_Block swig_types[108]
#define SWIGTYPE_p__dwg_MLEADER_Content_MText swig_types[109]
#define SWIGTYPE_p__dwg_MLINESTYLE_line swig_types[110]
#define SWIGTYPE_p__dwg_MLINESTYLE_line_lt swig_types[111]
#define SWIGTYPE_p__dwg_MLINE_line swig_types[112]
#define SWIGTYPE_p__dwg_MLINE_vertex swig_types[113]
#define SWIGTYPE_p__dwg_OCD_Dimension swig_types[114]
#define SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry swig_types[115]
#define SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp swig_types[116]
#define SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings swig_types[117]
#define SWIGTYPE_p__dwg_POINTCLOUD_Clippings swig_types[118]
#define SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle swig_types[119]
#define SWIGTYPE_p__dwg_PROXY_LWPOLYLINE swig_types[120]
#define SWIGTYPE_p__dwg_R2004_Header swig_types[121]
#define SWIGTYPE_p__dwg_SECTION_geometrysettings swig_types[122]
#define SWIGTYPE_p__dwg_SECTION_typesettings swig_types[123]
#define SWIGTYPE_p__dwg_SPLINE_control_point swig_types[124]
#define SWIGTYPE_p__dwg_SUNSTUDY_Dates swig_types[125]
#define SWIGTYPE_p__dwg_SummaryInfo_Property swig_types[126]
#define SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell swig_types[127]
#define SWIGTYPE_p__dwg_TABLESTYLE_CellStyle swig_types[128]
#define SWIGTYPE_p__dwg_TABLESTYLE_border swig_types[129]
#define SWIGTYPE_p__dwg_TABLESTYLE_rowstyles swig_types[130]
#define SWIGTYPE_p__dwg_TABLE_AttrDef swig_types[131]
#define SWIGTYPE_p__dwg_TABLE_BreakHeight swig_types[132]
#define SWIGTYPE_p__dwg_TABLE_BreakRow swig_types[133]
#define SWIGTYPE_p__dwg_TABLE_Cell swig_types[134]
#define SWIGTYPE_p__dwg_TABLE_CustomDataItem swig_types[135]
#define SWIGTYPE_p__dwg_TABLE_value swig_types[136]
#define SWIGTYPE_p__dwg_TableCell swig_types[137]
#define SWIGTYPE_p__dwg_TableCellContent swig_types[138]
#define SWIGTYPE_p__dwg_TableCellContent_Attr swig_types[139]
#define SWIGTYPE_p__dwg_TableDataColumn swig_types[140]
#define SWIGTYPE_p__dwg_TableRow swig_types[141]
#define SWIGTYPE_p__dwg_UCS_orthopts swig_types[142]
#define SWIGTYPE_p__dwg_VALUEPARAM swig_types[143]
#define SWIGTYPE_p__dwg_VALUEPARAM_vars swig_types[144]
#define SWIGTYPE_p__dwg_abstractentity_UNDERLAY swig_types[145]
#define SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS swig_types[146]
#define SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION swig_types[147]
#define SWIGTYPE_p__dwg_appinfo swig_types[148]
#define SWIGTYPE_p__dwg_appinfohistory swig_types[149]
#define SWIGTYPE_p__dwg_auxheader swig_types[150]
#define SWIGTYPE_p__dwg_binary_chunk swig_types[151]
#define SWIGTYPE_p__dwg_binary_chunk_u swig_types[152]
#define SWIGTYPE_p__dwg_bitcode_2bd swig_types[153]
#define SWIGTYPE_p__dwg_bitcode_2rd swig_types[154]
#define SWIGTYPE_p__dwg_bitcode_3bd swig_types[155]
#define SWIGTYPE_p__dwg_bitcode_3rd swig_types[156]
#define SWIGTYPE_p__dwg_chain swig_types[157]
#define SWIGTYPE_p__dwg_class swig_types[158]
#define SWIGTYPE_p__dwg_color swig_types[159]
#define SWIGTYPE_p__dwg_entity_3DFACE swig_types[160]
#define SWIGTYPE_p__dwg_entity_3DLINE swig_types[161]
#define SWIGTYPE_p__dwg_entity_3DSOLID swig_types[162]
#define SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY swig_types[163]
#define SWIGTYPE_p__dwg_entity_ARC swig_types[164]
#define SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT swig_types[165]
#define SWIGTYPE_p__dwg_entity_ARC_DIMENSION swig_types[166]
#define SWIGTYPE_p__dwg_entity_ATTDEF swig_types[167]
#define SWIGTYPE_p__dwg_entity_ATTRIB swig_types[168]
#define SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY swig_types[169]
#define SWIGTYPE_p__dwg_entity_BLOCK swig_types[170]
#define SWIGTYPE_p__dwg_entity_CAMERA swig_types[171]
#define SWIGTYPE_p__dwg_entity_CIRCLE swig_types[172]
#define SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED swig_types[173]
#define SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN swig_types[174]
#define SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT swig_types[175]
#define SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER swig_types[176]
#define SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR swig_types[177]
#define SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE swig_types[178]
#define SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS swig_types[179]
#define SWIGTYPE_p__dwg_entity_ELLIPSE swig_types[180]
#define SWIGTYPE_p__dwg_entity_ENDBLK swig_types[181]
#define SWIGTYPE_p__dwg_entity_ENDREP swig_types[182]
#define SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE swig_types[183]
#define SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY swig_types[184]
#define SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY swig_types[185]
#define SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER swig_types[186]
#define SWIGTYPE_p__dwg_entity_HATCH swig_types[187]
#define SWIGTYPE_p__dwg_entity_HELIX swig_types[188]
#define SWIGTYPE_p__dwg_entity_IMAGE swig_types[189]
#define SWIGTYPE_p__dwg_entity_INSERT swig_types[190]
#define SWIGTYPE_p__dwg_entity_JUMP swig_types[191]
#define SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION swig_types[192]
#define SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG swig_types[193]
#define SWIGTYPE_p__dwg_entity_LEADER swig_types[194]
#define SWIGTYPE_p__dwg_entity_LIGHT swig_types[195]
#define SWIGTYPE_p__dwg_entity_LINE swig_types[196]
#define SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY swig_types[197]
#define SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY swig_types[198]
#define SWIGTYPE_p__dwg_entity_LOAD swig_types[199]
#define SWIGTYPE_p__dwg_entity_LOFTEDSURFACE swig_types[200]
#define SWIGTYPE_p__dwg_entity_LWPOLYLINE swig_types[201]
#define SWIGTYPE_p__dwg_entity_MESH swig_types[202]
#define SWIGTYPE_p__dwg_entity_MINSERT swig_types[203]
#define SWIGTYPE_p__dwg_entity_MLINE swig_types[204]
#define SWIGTYPE_p__dwg_entity_MPOLYGON swig_types[205]
#define SWIGTYPE_p__dwg_entity_MTEXT swig_types[206]
#define SWIGTYPE_p__dwg_entity_MULTILEADER swig_types[207]
#define SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL swig_types[208]
#define SWIGTYPE_p__dwg_entity_NURBSURFACE swig_types[209]
#define SWIGTYPE_p__dwg_entity_OLE2FRAME swig_types[210]
#define SWIGTYPE_p__dwg_entity_OLEFRAME swig_types[211]
#define SWIGTYPE_p__dwg_entity_PLANESURFACE swig_types[212]
#define SWIGTYPE_p__dwg_entity_POINT swig_types[213]
#define SWIGTYPE_p__dwg_entity_POINTCLOUD swig_types[214]
#define SWIGTYPE_p__dwg_entity_POINTCLOUDEX swig_types[215]
#define SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY swig_types[216]
#define SWIGTYPE_p__dwg_entity_POLARGRIPENTITY swig_types[217]
#define SWIGTYPE_p__dwg_entity_POLYLINE_2D swig_types[218]
#define SWIGTYPE_p__dwg_entity_POLYLINE_3D swig_types[219]
#define SWIGTYPE_p__dwg_entity_POLYLINE_MESH swig_types[220]
#define SWIGTYPE_p__dwg_entity_POLYLINE_PFACE swig_types[221]
#define SWIGTYPE_p__dwg_entity_PROXY_ENTITY swig_types[222]
#define SWIGTYPE_p__dwg_entity_RAY swig_types[223]
#define SWIGTYPE_p__dwg_entity_REPEAT swig_types[224]
#define SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE swig_types[225]
#define SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY swig_types[226]
#define SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY swig_types[227]
#define SWIGTYPE_p__dwg_entity_RTEXT swig_types[228]
#define SWIGTYPE_p__dwg_entity_SECTIONOBJECT swig_types[229]
#define SWIGTYPE_p__dwg_entity_SEQEND swig_types[230]
#define SWIGTYPE_p__dwg_entity_SHAPE swig_types[231]
#define SWIGTYPE_p__dwg_entity_SOLID swig_types[232]
#define SWIGTYPE_p__dwg_entity_SPLINE swig_types[233]
#define SWIGTYPE_p__dwg_entity_SWEPTSURFACE swig_types[234]
#define SWIGTYPE_p__dwg_entity_TABLE swig_types[235]
#define SWIGTYPE_p__dwg_entity_TEXT swig_types[236]
#define SWIGTYPE_p__dwg_entity_TOLERANCE swig_types[237]
#define SWIGTYPE_p__dwg_entity_TRACE swig_types[238]
#define SWIGTYPE_p__dwg_entity_UNKNOWN_ENT swig_types[239]
#define SWIGTYPE_p__dwg_entity_VERTEX_2D swig_types[240]
#define SWIGTYPE_p__dwg_entity_VERTEX_3D swig_types[241]
#define SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE swig_types[242]
#define SWIGTYPE_p__dwg_entity_VIEWPORT swig_types[243]
#define SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY swig_types[244]
#define SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY swig_types[245]
#define SWIGTYPE_p__dwg_entity_WIPEOUT swig_types[246]
#define SWIGTYPE_p__dwg_entity_XYGRIPENTITY swig_types[247]
#define SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY swig_types[248]
#define SWIGTYPE_p__dwg_entity_eed swig_types[249]
#define SWIGTYPE_p__dwg_entity_eed_data swig_types[250]
#define SWIGTYPE_p__dwg_filedeplist swig_types[251]
#define SWIGTYPE_p__dwg_handle swig_types[252]
#define SWIGTYPE_p__dwg_header swig_types[253]
#define SWIGTYPE_p__dwg_header_variables swig_types[254]
#define SWIGTYPE_p__dwg_object swig_types[255]
#define SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY swig_types[256]
#define SWIGTYPE_p__dwg_object_ACMESCOPE swig_types[257]
#define SWIGTYPE_p__dwg_object_ACMESTATEMGR swig_types[258]
#define SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS swig_types[259]
#define SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS swig_types[260]
#define SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS swig_types[261]
#define SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS swig_types[262]
#define SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS swig_types[263]
#define SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS swig_types[264]
#define SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS swig_types[265]
#define SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS swig_types[266]
#define SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS swig_types[267]
#define SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS swig_types[268]
#define SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS swig_types[269]
#define SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS swig_types[270]
#define SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS swig_types[271]
#define SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS swig_types[272]
#define SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS swig_types[273]
#define SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS swig_types[274]
#define SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA swig_types[275]
#define SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA swig_types[276]
#define SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA swig_types[277]
#define SWIGTYPE_p__dwg_object_APPID swig_types[278]
#define SWIGTYPE_p__dwg_object_APPID_CONTROL swig_types[279]
#define SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP swig_types[280]
#define SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY swig_types[281]
#define SWIGTYPE_p__dwg_object_ASSOCACTION swig_types[282]
#define SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM swig_types[283]
#define SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY swig_types[284]
#define SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY swig_types[285]
#define SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY swig_types[286]
#define SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM swig_types[287]
#define SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY swig_types[288]
#define SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM swig_types[289]
#define SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY swig_types[290]
#define SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY swig_types[291]
#define SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM swig_types[292]
#define SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY swig_types[293]
#define SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY swig_types[294]
#define SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY swig_types[295]
#define SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY swig_types[296]
#define SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM swig_types[297]
#define SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY swig_types[298]
#define SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY swig_types[299]
#define SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY swig_types[300]
#define SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY swig_types[301]
#define SWIGTYPE_p__dwg_object_ASSOCNETWORK swig_types[302]
#define SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY swig_types[303]
#define SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM swig_types[304]
#define SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY swig_types[305]
#define SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY swig_types[306]
#define SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM swig_types[307]
#define SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY swig_types[308]
#define SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM swig_types[309]
#define SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER swig_types[310]
#define SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY swig_types[311]
#define SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM swig_types[312]
#define SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY swig_types[313]
#define SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY swig_types[314]
#define SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY swig_types[315]
#define SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY swig_types[316]
#define SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY swig_types[317]
#define SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY swig_types[318]
#define SWIGTYPE_p__dwg_object_ASSOCVARIABLE swig_types[319]
#define SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM swig_types[320]
#define SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA swig_types[321]
#define SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER swig_types[322]
#define SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP swig_types[323]
#define SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER swig_types[324]
#define SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER swig_types[325]
#define SWIGTYPE_p__dwg_object_BLOCKARRAYACTION swig_types[326]
#define SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER swig_types[327]
#define SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER swig_types[328]
#define SWIGTYPE_p__dwg_object_BLOCKFLIPACTION swig_types[329]
#define SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP swig_types[330]
#define SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER swig_types[331]
#define SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT swig_types[332]
#define SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER swig_types[333]
#define SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER swig_types[334]
#define SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP swig_types[335]
#define SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER swig_types[336]
#define SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION swig_types[337]
#define SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP swig_types[338]
#define SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER swig_types[339]
#define SWIGTYPE_p__dwg_object_BLOCKMOVEACTION swig_types[340]
#define SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY swig_types[341]
#define SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER swig_types[342]
#define SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP swig_types[343]
#define SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER swig_types[344]
#define SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION swig_types[345]
#define SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE swig_types[346]
#define SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP swig_types[347]
#define SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER swig_types[348]
#define SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION swig_types[349]
#define SWIGTYPE_p__dwg_object_BLOCKROTATEACTION swig_types[350]
#define SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP swig_types[351]
#define SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER swig_types[352]
#define SWIGTYPE_p__dwg_object_BLOCKSCALEACTION swig_types[353]
#define SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION swig_types[354]
#define SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER swig_types[355]
#define SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER swig_types[356]
#define SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP swig_types[357]
#define SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER swig_types[358]
#define SWIGTYPE_p__dwg_object_BLOCKXYGRIP swig_types[359]
#define SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER swig_types[360]
#define SWIGTYPE_p__dwg_object_BLOCK_CONTROL swig_types[361]
#define SWIGTYPE_p__dwg_object_BLOCK_HEADER swig_types[362]
#define SWIGTYPE_p__dwg_object_BREAKDATA swig_types[363]
#define SWIGTYPE_p__dwg_object_BREAKPOINTREF swig_types[364]
#define SWIGTYPE_p__dwg_object_CELLSTYLEMAP swig_types[365]
#define SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER swig_types[366]
#define SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS swig_types[367]
#define SWIGTYPE_p__dwg_object_CURVEPATH swig_types[368]
#define SWIGTYPE_p__dwg_object_DATALINK swig_types[369]
#define SWIGTYPE_p__dwg_object_DATATABLE swig_types[370]
#define SWIGTYPE_p__dwg_object_DBCOLOR swig_types[371]
#define SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE swig_types[372]
#define SWIGTYPE_p__dwg_object_DICTIONARY swig_types[373]
#define SWIGTYPE_p__dwg_object_DICTIONARYVAR swig_types[374]
#define SWIGTYPE_p__dwg_object_DICTIONARYWDFLT swig_types[375]
#define SWIGTYPE_p__dwg_object_DIMASSOC swig_types[376]
#define SWIGTYPE_p__dwg_object_DIMSTYLE swig_types[377]
#define SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL swig_types[378]
#define SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA swig_types[379]
#define SWIGTYPE_p__dwg_object_DUMMY swig_types[380]
#define SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE swig_types[381]
#define SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER swig_types[382]
#define SWIGTYPE_p__dwg_object_EVALUATION_GRAPH swig_types[383]
#define SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA swig_types[384]
#define SWIGTYPE_p__dwg_object_FIELD swig_types[385]
#define SWIGTYPE_p__dwg_object_FIELDLIST swig_types[386]
#define SWIGTYPE_p__dwg_object_GEODATA swig_types[387]
#define SWIGTYPE_p__dwg_object_GEOMAPIMAGE swig_types[388]
#define SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND swig_types[389]
#define SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND swig_types[390]
#define SWIGTYPE_p__dwg_object_GROUP swig_types[391]
#define SWIGTYPE_p__dwg_object_IBL_BACKGROUND swig_types[392]
#define SWIGTYPE_p__dwg_object_IDBUFFER swig_types[393]
#define SWIGTYPE_p__dwg_object_IMAGEDEF swig_types[394]
#define SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR swig_types[395]
#define SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND swig_types[396]
#define SWIGTYPE_p__dwg_object_INDEX swig_types[397]
#define SWIGTYPE_p__dwg_object_LAYER swig_types[398]
#define SWIGTYPE_p__dwg_object_LAYERFILTER swig_types[399]
#define SWIGTYPE_p__dwg_object_LAYER_CONTROL swig_types[400]
#define SWIGTYPE_p__dwg_object_LAYER_INDEX swig_types[401]
#define SWIGTYPE_p__dwg_object_LAYOUT swig_types[402]
#define SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA swig_types[403]
#define SWIGTYPE_p__dwg_object_LIGHTLIST swig_types[404]
#define SWIGTYPE_p__dwg_object_LONG_TRANSACTION swig_types[405]
#define SWIGTYPE_p__dwg_object_LTYPE swig_types[406]
#define SWIGTYPE_p__dwg_object_LTYPE_CONTROL swig_types[407]
#define SWIGTYPE_p__dwg_object_MATERIAL swig_types[408]
#define SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS swig_types[409]
#define SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA swig_types[410]
#define SWIGTYPE_p__dwg_object_MLEADERSTYLE swig_types[411]
#define SWIGTYPE_p__dwg_object_MLINESTYLE swig_types[412]
#define SWIGTYPE_p__dwg_object_MOTIONPATH swig_types[413]
#define SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA swig_types[414]
#define SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA swig_types[415]
#define SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF swig_types[416]
#define SWIGTYPE_p__dwg_object_OBJECT_PTR swig_types[417]
#define SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA swig_types[418]
#define SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX swig_types[419]
#define SWIGTYPE_p__dwg_object_PERSUBENTMGR swig_types[420]
#define SWIGTYPE_p__dwg_object_PLACEHOLDER swig_types[421]
#define SWIGTYPE_p__dwg_object_PLOTSETTINGS swig_types[422]
#define SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP swig_types[423]
#define SWIGTYPE_p__dwg_object_POINTCLOUDDEF swig_types[424]
#define SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX swig_types[425]
#define SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR swig_types[426]
#define SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX swig_types[427]
#define SWIGTYPE_p__dwg_object_POINTPATH swig_types[428]
#define SWIGTYPE_p__dwg_object_PROXY_OBJECT swig_types[429]
#define SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA swig_types[430]
#define SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA swig_types[431]
#define SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS swig_types[432]
#define SWIGTYPE_p__dwg_object_RASTERVARIABLES swig_types[433]
#define SWIGTYPE_p__dwg_object_RENDERENTRY swig_types[434]
#define SWIGTYPE_p__dwg_object_RENDERENVIRONMENT swig_types[435]
#define SWIGTYPE_p__dwg_object_RENDERGLOBAL swig_types[436]
#define SWIGTYPE_p__dwg_object_RENDERSETTINGS swig_types[437]
#define SWIGTYPE_p__dwg_object_SCALE swig_types[438]
#define SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE swig_types[439]
#define SWIGTYPE_p__dwg_object_SECTION_MANAGER swig_types[440]
#define SWIGTYPE_p__dwg_object_SECTION_SETTINGS swig_types[441]
#define SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND swig_types[442]
#define SWIGTYPE_p__dwg_object_SOLID_BACKGROUND swig_types[443]
#define SWIGTYPE_p__dwg_object_SORTENTSTABLE swig_types[444]
#define SWIGTYPE_p__dwg_object_SPATIAL_FILTER swig_types[445]
#define SWIGTYPE_p__dwg_object_SPATIAL_INDEX swig_types[446]
#define SWIGTYPE_p__dwg_object_STYLE swig_types[447]
#define SWIGTYPE_p__dwg_object_STYLE_CONTROL swig_types[448]
#define SWIGTYPE_p__dwg_object_SUN swig_types[449]
#define SWIGTYPE_p__dwg_object_SUNSTUDY swig_types[450]
#define SWIGTYPE_p__dwg_object_TABLECONTENT swig_types[451]
#define SWIGTYPE_p__dwg_object_TABLEGEOMETRY swig_types[452]
#define SWIGTYPE_p__dwg_object_TABLESTYLE swig_types[453]
#define SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA swig_types[454]
#define SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES swig_types[455]
#define SWIGTYPE_p__dwg_object_UCS swig_types[456]
#define SWIGTYPE_p__dwg_object_UCS_CONTROL swig_types[457]
#define SWIGTYPE_p__dwg_object_UNKNOWN_OBJ swig_types[458]
#define SWIGTYPE_p__dwg_object_VBA_PROJECT swig_types[459]
#define SWIGTYPE_p__dwg_object_VIEW swig_types[460]
#define SWIGTYPE_p__dwg_object_VIEW_CONTROL swig_types[461]
#define SWIGTYPE_p__dwg_object_VISUALSTYLE swig_types[462]
#define SWIGTYPE_p__dwg_object_VPORT swig_types[463]
#define SWIGTYPE_p__dwg_object_VPORT_CONTROL swig_types[464]
#define SWIGTYPE_p__dwg_object_VX_CONTROL swig_types[465]
#define SWIGTYPE_p__dwg_object_VX_TABLE_RECORD swig_types[466]
#define SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES swig_types[467]
#define SWIGTYPE_p__dwg_object_XRECORD swig_types[468]
#define SWIGTYPE_p__dwg_object_entity swig_types[469]
#define SWIGTYPE_p__dwg_object_entity_tio swig_types[470]
#define SWIGTYPE_p__dwg_object_object swig_types[471]
#define SWIGTYPE_p__dwg_object_object_tio swig_types[472]
#define SWIGTYPE_p__dwg_object_ref swig_types[473]
#define SWIGTYPE_p__dwg_object_tio swig_types[474]
#define SWIGTYPE_p__dwg_objfreespace swig_types[475]
#define SWIGTYPE_p__dwg_resbuf swig_types[476]
#define SWIGTYPE_p__dwg_resbuf_value swig_types[477]
#define SWIGTYPE_p__dwg_revhistory swig_types[478]
#define SWIGTYPE_p__dwg_secondheader swig_types[479]
#define SWIGTYPE_p__dwg_secondheader_handles swig_types[480]
#define SWIGTYPE_p__dwg_secondheader_sections swig_types[481]
#define SWIGTYPE_p__dwg_section swig_types[482]
#define SWIGTYPE_p__dwg_security swig_types[483]
#define SWIGTYPE_p__dwg_struct swig_types[484]
#define SWIGTYPE_p__dwg_struct_fhdr swig_types[485]
#define SWIGTYPE_p__dwg_summaryinfo swig_types[486]
#define SWIGTYPE_p__dwg_template swig_types[487]
#define SWIGTYPE_p__dwg_time_bll swig_types[488]
#define SWIGTYPE_p__dwg_vbaproject swig_types[489]
#define SWIGTYPE_p__inthash swig_types[490]
#define SWIGTYPE_p_char swig_types[491]
#define SWIGTYPE_p_double swig_types[492]
#define SWIGTYPE_p_dwg_entity_DIMENSION_common swig_types[493]
#define SWIGTYPE_p_dwg_field_name_type_offset swig_types[494]
#define SWIGTYPE_p_dwg_obj_ent swig_types[495]
#define SWIGTYPE_p_dwg_obj_generic swig_types[496]
#define SWIGTYPE_p_dwg_obj_layer swig_types[497]
#define SWIGTYPE_p_dwg_obj_obj swig_types[498]
#define SWIGTYPE_p_dwg_object swig_types[499]
#define SWIGTYPE_p_dwg_versions swig_types[500]
#define SWIGTYPE_p_eed_data_t swig_types[501]
#define SWIGTYPE_p_eed_data_t_eed_0 swig_types[502]
#define SWIGTYPE_p_eed_data_t_eed_0_r2007 swig_types[503]
#define SWIGTYPE_p_eed_data_t_eed_1 swig_types[504]
#define SWIGTYPE_p_eed_data_t_eed_10 swig_types[505]
#define SWIGTYPE_p_eed_data_t_eed_2 swig_types[506]
#define SWIGTYPE_p_eed_data_t_eed_3 swig_types[507]
#define SWIGTYPE_p_eed_data_t_eed_4 swig_types[508]
#define SWIGTYPE_p_eed_data_t_eed_40 swig_types[509]
#define SWIGTYPE_p_eed_data_t_eed_5 swig_types[510]
#define SWIGTYPE_p_eed_data_t_eed_70 swig_types[511]
#define SWIGTYPE_p_eed_data_t_eed_71 swig_types[512]
#define SWIGTYPE_p_int swig_types[513]
#define SWIGTYPE_p_long_long swig_types[514]
#define SWIGTYPE_p_p__dwg_abstractentity_UNDERLAY swig_types[515]
#define SWIGTYPE_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS swig_types[516]
#define SWIGTYPE_p_p__dwg_abstractobject_UNDERLAYDEFINITION swig_types[517]
#define SWIGTYPE_p_p__dwg_entity_3DFACE swig_types[518]
#define SWIGTYPE_p_p__dwg_entity_3DLINE swig_types[519]
#define SWIGTYPE_p_p__dwg_entity_3DSOLID swig_types[520]
#define SWIGTYPE_p_p__dwg_entity_ARC swig_types[521]
#define SWIGTYPE_p_p__dwg_entity_ARC_DIMENSION swig_types[522]
#define SWIGTYPE_p_p__dwg_entity_ATTDEF swig_types[523]
#define SWIGTYPE_p_p__dwg_entity_ATTRIB swig_types[524]
#define SWIGTYPE_p_p__dwg_entity_BLOCK swig_types[525]
#define SWIGTYPE_p_p__dwg_entity_CAMERA swig_types[526]
#define SWIGTYPE_p_p__dwg_entity_CIRCLE swig_types[527]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_ALIGNED swig_types[528]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_ANG2LN swig_types[529]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_ANG3PT swig_types[530]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_DIAMETER swig_types[531]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_LINEAR swig_types[532]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_ORDINATE swig_types[533]
#define SWIGTYPE_p_p__dwg_entity_DIMENSION_RADIUS swig_types[534]
#define SWIGTYPE_p_p__dwg_entity_ELLIPSE swig_types[535]
#define SWIGTYPE_p_p__dwg_entity_ENDBLK swig_types[536]
#define SWIGTYPE_p_p__dwg_entity_ENDREP swig_types[537]
#define SWIGTYPE_p_p__dwg_entity_HATCH swig_types[538]
#define SWIGTYPE_p_p__dwg_entity_HELIX swig_types[539]
#define SWIGTYPE_p_p__dwg_entity_IMAGE swig_types[540]
#define SWIGTYPE_p_p__dwg_entity_INSERT swig_types[541]
#define SWIGTYPE_p_p__dwg_entity_JUMP swig_types[542]
#define SWIGTYPE_p_p__dwg_entity_LARGE_RADIAL_DIMENSION swig_types[543]
#define SWIGTYPE_p_p__dwg_entity_LAYOUTPRINTCONFIG swig_types[544]
#define SWIGTYPE_p_p__dwg_entity_LEADER swig_types[545]
#define SWIGTYPE_p_p__dwg_entity_LIGHT swig_types[546]
#define SWIGTYPE_p_p__dwg_entity_LINE swig_types[547]
#define SWIGTYPE_p_p__dwg_entity_LOAD swig_types[548]
#define SWIGTYPE_p_p__dwg_entity_LWPOLYLINE swig_types[549]
#define SWIGTYPE_p_p__dwg_entity_MESH swig_types[550]
#define SWIGTYPE_p_p__dwg_entity_MINSERT swig_types[551]
#define SWIGTYPE_p_p__dwg_entity_MLINE swig_types[552]
#define SWIGTYPE_p_p__dwg_entity_MTEXT swig_types[553]
#define SWIGTYPE_p_p__dwg_entity_MULTILEADER swig_types[554]
#define SWIGTYPE_p_p__dwg_entity_OLE2FRAME swig_types[555]
#define SWIGTYPE_p_p__dwg_entity_OLEFRAME swig_types[556]
#define SWIGTYPE_p_p__dwg_entity_PLANESURFACE swig_types[557]
#define SWIGTYPE_p_p__dwg_entity_POINT swig_types[558]
#define SWIGTYPE_p_p__dwg_entity_POINTCLOUD swig_types[559]
#define SWIGTYPE_p_p__dwg_entity_POINTCLOUDEX swig_types[560]
#define SWIGTYPE_p_p__dwg_entity_POLYLINE_2D swig_types[561]
#define SWIGTYPE_p_p__dwg_entity_POLYLINE_3D swig_types[562]
#define SWIGTYPE_p_p__dwg_entity_POLYLINE_MESH swig_types[563]
#define SWIGTYPE_p_p__dwg_entity_POLYLINE_PFACE swig_types[564]
#define SWIGTYPE_p_p__dwg_entity_PROXY_ENTITY swig_types[565]
#define SWIGTYPE_p_p__dwg_entity_RAY swig_types[566]
#define SWIGTYPE_p_p__dwg_entity_REPEAT swig_types[567]
#define SWIGTYPE_p_p__dwg_entity_SECTIONOBJECT swig_types[568]
#define SWIGTYPE_p_p__dwg_entity_SEQEND swig_types[569]
#define SWIGTYPE_p_p__dwg_entity_SHAPE swig_types[570]
#define SWIGTYPE_p_p__dwg_entity_SOLID swig_types[571]
#define SWIGTYPE_p_p__dwg_entity_SPLINE swig_types[572]
#define SWIGTYPE_p_p__dwg_entity_TEXT swig_types[573]
#define SWIGTYPE_p_p__dwg_entity_TOLERANCE swig_types[574]
#define SWIGTYPE_p_p__dwg_entity_TRACE swig_types[575]
#define SWIGTYPE_p_p__dwg_entity_UNKNOWN_ENT swig_types[576]
#define SWIGTYPE_p_p__dwg_entity_VERTEX_2D swig_types[577]
#define SWIGTYPE_p_p__dwg_entity_VERTEX_3D swig_types[578]
#define SWIGTYPE_p_p__dwg_entity_VERTEX_PFACE_FACE swig_types[579]
#define SWIGTYPE_p_p__dwg_entity_VIEWPORT swig_types[580]
#define SWIGTYPE_p_p__dwg_entity_WIPEOUT swig_types[581]
#define SWIGTYPE_p_p__dwg_object_ACSH_BOOLEAN_CLASS swig_types[582]
#define SWIGTYPE_p_p__dwg_object_ACSH_BOX_CLASS swig_types[583]
#define SWIGTYPE_p_p__dwg_object_ACSH_BREP_CLASS swig_types[584]
#define SWIGTYPE_p_p__dwg_object_ACSH_CHAMFER_CLASS swig_types[585]
#define SWIGTYPE_p_p__dwg_object_ACSH_CONE_CLASS swig_types[586]
#define SWIGTYPE_p_p__dwg_object_ACSH_CYLINDER_CLASS swig_types[587]
#define SWIGTYPE_p_p__dwg_object_ACSH_FILLET_CLASS swig_types[588]
#define SWIGTYPE_p_p__dwg_object_ACSH_HISTORY_CLASS swig_types[589]
#define SWIGTYPE_p_p__dwg_object_ACSH_PYRAMID_CLASS swig_types[590]
#define SWIGTYPE_p_p__dwg_object_ACSH_SPHERE_CLASS swig_types[591]
#define SWIGTYPE_p_p__dwg_object_ACSH_TORUS_CLASS swig_types[592]
#define SWIGTYPE_p_p__dwg_object_ACSH_WEDGE_CLASS swig_types[593]
#define SWIGTYPE_p_p__dwg_object_ALDIMOBJECTCONTEXTDATA swig_types[594]
#define SWIGTYPE_p_p__dwg_object_APPID swig_types[595]
#define SWIGTYPE_p_p__dwg_object_APPID_CONTROL swig_types[596]
#define SWIGTYPE_p_p__dwg_object_ASSOC2DCONSTRAINTGROUP swig_types[597]
#define SWIGTYPE_p_p__dwg_object_ASSOCACTION swig_types[598]
#define SWIGTYPE_p_p__dwg_object_ASSOCACTIONPARAM swig_types[599]
#define SWIGTYPE_p_p__dwg_object_ASSOCARRAYACTIONBODY swig_types[600]
#define SWIGTYPE_p_p__dwg_object_ASSOCASMBODYACTIONPARAM swig_types[601]
#define SWIGTYPE_p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY swig_types[602]
#define SWIGTYPE_p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM swig_types[603]
#define SWIGTYPE_p_p__dwg_object_ASSOCDEPENDENCY swig_types[604]
#define SWIGTYPE_p_p__dwg_object_ASSOCDIMDEPENDENCYBODY swig_types[605]
#define SWIGTYPE_p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY swig_types[606]
#define SWIGTYPE_p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY swig_types[607]
#define SWIGTYPE_p_p__dwg_object_ASSOCFACEACTIONPARAM swig_types[608]
#define SWIGTYPE_p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY swig_types[609]
#define SWIGTYPE_p_p__dwg_object_ASSOCGEOMDEPENDENCY swig_types[610]
#define SWIGTYPE_p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY swig_types[611]
#define SWIGTYPE_p_p__dwg_object_ASSOCNETWORK swig_types[612]
#define SWIGTYPE_p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY swig_types[613]
#define SWIGTYPE_p_p__dwg_object_ASSOCOBJECTACTIONPARAM swig_types[614]
#define SWIGTYPE_p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY swig_types[615]
#define SWIGTYPE_p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM swig_types[616]
#define SWIGTYPE_p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY swig_types[617]
#define SWIGTYPE_p_p__dwg_object_ASSOCPATHACTIONPARAM swig_types[618]
#define SWIGTYPE_p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY swig_types[619]
#define SWIGTYPE_p_p__dwg_object_ASSOCPOINTREFACTIONPARAM swig_types[620]
#define SWIGTYPE_p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY swig_types[621]
#define SWIGTYPE_p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY swig_types[622]
#define SWIGTYPE_p_p__dwg_object_ASSOCVALUEDEPENDENCY swig_types[623]
#define SWIGTYPE_p_p__dwg_object_ASSOCVARIABLE swig_types[624]
#define SWIGTYPE_p_p__dwg_object_ASSOCVERTEXACTIONPARAM swig_types[625]
#define SWIGTYPE_p_p__dwg_object_BLKREFOBJECTCONTEXTDATA swig_types[626]
#define SWIGTYPE_p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER swig_types[627]
#define SWIGTYPE_p_p__dwg_object_BLOCKALIGNMENTGRIP swig_types[628]
#define SWIGTYPE_p_p__dwg_object_BLOCKALIGNMENTPARAMETER swig_types[629]
#define SWIGTYPE_p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER swig_types[630]
#define SWIGTYPE_p_p__dwg_object_BLOCKARRAYACTION swig_types[631]
#define SWIGTYPE_p_p__dwg_object_BLOCKBASEPOINTPARAMETER swig_types[632]
#define SWIGTYPE_p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER swig_types[633]
#define SWIGTYPE_p_p__dwg_object_BLOCKFLIPACTION swig_types[634]
#define SWIGTYPE_p_p__dwg_object_BLOCKFLIPGRIP swig_types[635]
#define SWIGTYPE_p_p__dwg_object_BLOCKFLIPPARAMETER swig_types[636]
#define SWIGTYPE_p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT swig_types[637]
#define SWIGTYPE_p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER swig_types[638]
#define SWIGTYPE_p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER swig_types[639]
#define SWIGTYPE_p_p__dwg_object_BLOCKLINEARGRIP swig_types[640]
#define SWIGTYPE_p_p__dwg_object_BLOCKLINEARPARAMETER swig_types[641]
#define SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPACTION swig_types[642]
#define SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPGRIP swig_types[643]
#define SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPPARAMETER swig_types[644]
#define SWIGTYPE_p_p__dwg_object_BLOCKMOVEACTION swig_types[645]
#define SWIGTYPE_p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY swig_types[646]
#define SWIGTYPE_p_p__dwg_object_BLOCKPOINTPARAMETER swig_types[647]
#define SWIGTYPE_p_p__dwg_object_BLOCKPOLARGRIP swig_types[648]
#define SWIGTYPE_p_p__dwg_object_BLOCKPOLARPARAMETER swig_types[649]
#define SWIGTYPE_p_p__dwg_object_BLOCKPOLARSTRETCHACTION swig_types[650]
#define SWIGTYPE_p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER swig_types[651]
#define SWIGTYPE_p_p__dwg_object_BLOCKREPRESENTATION swig_types[652]
#define SWIGTYPE_p_p__dwg_object_BLOCKROTATEACTION swig_types[653]
#define SWIGTYPE_p_p__dwg_object_BLOCKROTATIONGRIP swig_types[654]
#define SWIGTYPE_p_p__dwg_object_BLOCKROTATIONPARAMETER swig_types[655]
#define SWIGTYPE_p_p__dwg_object_BLOCKSCALEACTION swig_types[656]
#define SWIGTYPE_p_p__dwg_object_BLOCKSTRETCHACTION swig_types[657]
#define SWIGTYPE_p_p__dwg_object_BLOCKUSERPARAMETER swig_types[658]
#define SWIGTYPE_p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER swig_types[659]
#define SWIGTYPE_p_p__dwg_object_BLOCKVISIBILITYGRIP swig_types[660]
#define SWIGTYPE_p_p__dwg_object_BLOCKVISIBILITYPARAMETER swig_types[661]
#define SWIGTYPE_p_p__dwg_object_BLOCKXYGRIP swig_types[662]
#define SWIGTYPE_p_p__dwg_object_BLOCKXYPARAMETER swig_types[663]
#define SWIGTYPE_p_p__dwg_object_BLOCK_CONTROL swig_types[664]
#define SWIGTYPE_p_p__dwg_object_BLOCK_HEADER swig_types[665]
#define SWIGTYPE_p_p__dwg_object_CELLSTYLEMAP swig_types[666]
#define SWIGTYPE_p_p__dwg_object_DATALINK swig_types[667]
#define SWIGTYPE_p_p__dwg_object_DBCOLOR swig_types[668]
#define SWIGTYPE_p_p__dwg_object_DETAILVIEWSTYLE swig_types[669]
#define SWIGTYPE_p_p__dwg_object_DICTIONARY swig_types[670]
#define SWIGTYPE_p_p__dwg_object_DICTIONARYVAR swig_types[671]
#define SWIGTYPE_p_p__dwg_object_DICTIONARYWDFLT swig_types[672]
#define SWIGTYPE_p_p__dwg_object_DIMSTYLE swig_types[673]
#define SWIGTYPE_p_p__dwg_object_DIMSTYLE_CONTROL swig_types[674]
#define SWIGTYPE_p_p__dwg_object_DUMMY swig_types[675]
#define SWIGTYPE_p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER swig_types[676]
#define SWIGTYPE_p_p__dwg_object_EVALUATION_GRAPH swig_types[677]
#define SWIGTYPE_p_p__dwg_object_FCFOBJECTCONTEXTDATA swig_types[678]
#define SWIGTYPE_p_p__dwg_object_FIELD swig_types[679]
#define SWIGTYPE_p_p__dwg_object_FIELDLIST swig_types[680]
#define SWIGTYPE_p_p__dwg_object_GEODATA swig_types[681]
#define SWIGTYPE_p_p__dwg_object_GRADIENT_BACKGROUND swig_types[682]
#define SWIGTYPE_p_p__dwg_object_GROUND_PLANE_BACKGROUND swig_types[683]
#define SWIGTYPE_p_p__dwg_object_GROUP swig_types[684]
#define SWIGTYPE_p_p__dwg_object_IBL_BACKGROUND swig_types[685]
#define SWIGTYPE_p_p__dwg_object_IDBUFFER swig_types[686]
#define SWIGTYPE_p_p__dwg_object_IMAGEDEF swig_types[687]
#define SWIGTYPE_p_p__dwg_object_IMAGEDEF_REACTOR swig_types[688]
#define SWIGTYPE_p_p__dwg_object_IMAGE_BACKGROUND swig_types[689]
#define SWIGTYPE_p_p__dwg_object_INDEX swig_types[690]
#define SWIGTYPE_p_p__dwg_object_LAYER swig_types[691]
#define SWIGTYPE_p_p__dwg_object_LAYERFILTER swig_types[692]
#define SWIGTYPE_p_p__dwg_object_LAYER_CONTROL swig_types[693]
#define SWIGTYPE_p_p__dwg_object_LAYER_INDEX swig_types[694]
#define SWIGTYPE_p_p__dwg_object_LAYOUT swig_types[695]
#define SWIGTYPE_p_p__dwg_object_LEADEROBJECTCONTEXTDATA swig_types[696]
#define SWIGTYPE_p_p__dwg_object_LIGHTLIST swig_types[697]
#define SWIGTYPE_p_p__dwg_object_LONG_TRANSACTION swig_types[698]
#define SWIGTYPE_p_p__dwg_object_LTYPE swig_types[699]
#define SWIGTYPE_p_p__dwg_object_LTYPE_CONTROL swig_types[700]
#define SWIGTYPE_p_p__dwg_object_MATERIAL swig_types[701]
#define SWIGTYPE_p_p__dwg_object_MENTALRAYRENDERSETTINGS swig_types[702]
#define SWIGTYPE_p_p__dwg_object_MLEADERSTYLE swig_types[703]
#define SWIGTYPE_p_p__dwg_object_MLINESTYLE swig_types[704]
#define SWIGTYPE_p_p__dwg_object_MTEXTOBJECTCONTEXTDATA swig_types[705]
#define SWIGTYPE_p_p__dwg_object_OBJECT_PTR swig_types[706]
#define SWIGTYPE_p_p__dwg_object_PARTIAL_VIEWING_INDEX swig_types[707]
#define SWIGTYPE_p_p__dwg_object_PLACEHOLDER swig_types[708]
#define SWIGTYPE_p_p__dwg_object_PLOTSETTINGS swig_types[709]
#define SWIGTYPE_p_p__dwg_object_POINTCLOUDCOLORMAP swig_types[710]
#define SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF swig_types[711]
#define SWIGTYPE_p_p__dwg_object_POINTCLOUDDEFEX swig_types[712]
#define SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF_REACTOR swig_types[713]
#define SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX swig_types[714]
#define SWIGTYPE_p_p__dwg_object_PROXY_OBJECT swig_types[715]
#define SWIGTYPE_p_p__dwg_object_RAPIDRTRENDERSETTINGS swig_types[716]
#define SWIGTYPE_p_p__dwg_object_RASTERVARIABLES swig_types[717]
#define SWIGTYPE_p_p__dwg_object_RENDERENTRY swig_types[718]
#define SWIGTYPE_p_p__dwg_object_RENDERENVIRONMENT swig_types[719]
#define SWIGTYPE_p_p__dwg_object_RENDERGLOBAL swig_types[720]
#define SWIGTYPE_p_p__dwg_object_RENDERSETTINGS swig_types[721]
#define SWIGTYPE_p_p__dwg_object_SCALE swig_types[722]
#define SWIGTYPE_p_p__dwg_object_SECTIONVIEWSTYLE swig_types[723]
#define SWIGTYPE_p_p__dwg_object_SECTION_MANAGER swig_types[724]
#define SWIGTYPE_p_p__dwg_object_SECTION_SETTINGS swig_types[725]
#define SWIGTYPE_p_p__dwg_object_SKYLIGHT_BACKGROUND swig_types[726]
#define SWIGTYPE_p_p__dwg_object_SOLID_BACKGROUND swig_types[727]
#define SWIGTYPE_p_p__dwg_object_SORTENTSTABLE swig_types[728]
#define SWIGTYPE_p_p__dwg_object_SPATIAL_FILTER swig_types[729]
#define SWIGTYPE_p_p__dwg_object_SPATIAL_INDEX swig_types[730]
#define SWIGTYPE_p_p__dwg_object_STYLE swig_types[731]
#define SWIGTYPE_p_p__dwg_object_STYLE_CONTROL swig_types[732]
#define SWIGTYPE_p_p__dwg_object_SUN swig_types[733]
#define SWIGTYPE_p_p__dwg_object_TABLEGEOMETRY swig_types[734]
#define SWIGTYPE_p_p__dwg_object_TABLESTYLE swig_types[735]
#define SWIGTYPE_p_p__dwg_object_TEXTOBJECTCONTEXTDATA swig_types[736]
#define SWIGTYPE_p_p__dwg_object_UCS swig_types[737]
#define SWIGTYPE_p_p__dwg_object_UCS_CONTROL swig_types[738]
#define SWIGTYPE_p_p__dwg_object_UNKNOWN_OBJ swig_types[739]
#define SWIGTYPE_p_p__dwg_object_VBA_PROJECT swig_types[740]
#define SWIGTYPE_p_p__dwg_object_VIEW swig_types[741]
#define SWIGTYPE_p_p__dwg_object_VIEW_CONTROL swig_types[742]
#define SWIGTYPE_p_p__dwg_object_VISUALSTYLE swig_types[743]
#define SWIGTYPE_p_p__dwg_object_VPORT swig_types[744]
#define SWIGTYPE_p_p__dwg_object_VPORT_CONTROL swig_types[745]
#define SWIGTYPE_p_p__dwg_object_VX_CONTROL swig_types[746]
#define SWIGTYPE_p_p__dwg_object_VX_TABLE_RECORD swig_types[747]
#define SWIGTYPE_p_p__dwg_object_WIPEOUTVARIABLES swig_types[748]
#define SWIGTYPE_p_p__dwg_object_XRECORD swig_types[749]
#define SWIGTYPE_p_p__dwg_object_entity swig_types[750]
#define SWIGTYPE_p_p__dwg_object_ref swig_types[751]
#define SWIGTYPE_p_p__dwg_section swig_types[752]
#define SWIGTYPE_p_p_char swig_types[753]
#define SWIGTYPE_p_r2007_file_header swig_types[754]
#define SWIGTYPE_p_rgbpalette swig_types[755]
#define SWIGTYPE_p_short swig_types[756]
#define SWIGTYPE_p_signed_char swig_types[757]
#define SWIGTYPE_p_unsigned_char swig_types[758]
#define SWIGTYPE_p_unsigned_int swig_types[759]
#define SWIGTYPE_p_unsigned_long_long swig_types[760]
#define SWIGTYPE_p_unsigned_short swig_types[761]
static swig_type_info *swig_types[763];
static swig_module_info swig_module = {swig_types, 762, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _LibreDWG.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__LibreDWG

#else
#  define SWIG_init    init_LibreDWG

#endif

#define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 


#include "../src/config.h"
#include "dwg_api.h"


#include <stdint.h>		// Use the C99 official header


  static Dwg_Object *new_Dwg_Object_Array(size_t nelements) { 
    return (Dwg_Object *)calloc(nelements, sizeof(Dwg_Object));
  }

  static void delete_Dwg_Object_Array(Dwg_Object *ary) {
    free((char*)ary);
  }

  static Dwg_Object Dwg_Object_Array_getitem(Dwg_Object *ary, size_t index) {
    return ary[index];
  }
  static void Dwg_Object_Array_setitem(Dwg_Object *ary, size_t index, Dwg_Object value) {
    ary[index] = value;
  }


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = (size_t)(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = (size_t)(v);
  }
#endif
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static swig_type_info* info = 0;
  if (!info) {
    info = SWIG_TypeQuery("_p_char");
  }
  return info;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
#else
      return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (unsigned int)(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (int)(v);
    }
  }  
  return res;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (unsigned char)(v);
    }
  }  
  return res;
}


  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong((long)(value));
}
#endif


SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (short)(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (unsigned short)(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}




typedef union {
  char *data;
  dwg_wchar_t *wdata;
} _dwg_binary_chunk_u;

typedef union {
  double  pt[3];
  char    i8;
  short   i16;
  int     i32;
  BITCODE_BLL i64;
  BITCODE_HV absref;
  double  dbl;
  struct _dwg_binary_chunk str;
} _dwg_resbuf_value;


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	free((char*)cptr);
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) free((char*)cptr);
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = (char)(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}

typedef union {
  BITCODE_BSd index;                   
  BITCODE_H   ltype;                   
} _dwg_MLINESTYLE_line_lt;

typedef union {
  BITCODE_BD bd;
  BITCODE_BL bl;
  BITCODE_BS bs;
  BITCODE_RC rc;
  BITCODE_TV text;
  BITCODE_H handle;
} _dwg_EvalVariant_u;

typedef union {
  BITCODE_BD  num40;
  BITCODE_2RD pt2d;
  BITCODE_3BD pt3d;
  BITCODE_TV   text1;
  BITCODE_BL  long90;
  BITCODE_H   handle91;
  BITCODE_BS  short70;
} _dwg_EvalExpr_value;


SWIGINTERN int
SWIG_AsVal_signed_SS_char (PyObject * obj, signed char *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SCHAR_MIN || v > SCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (signed char)(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_signed_SS_char  (signed char value)
{    
  return SWIG_From_long  (value);
}

typedef struct {
  BITCODE_RS length;                  
  unsigned short codepage:15;            
  unsigned short is_tu:1;
  
  
  
  
  char string[0];                                                            
  
} eed_data_t_eed_0;

typedef struct {
  BITCODE_RS length;
  unsigned short _padding:15;
  unsigned short is_tu:1;
  
  
  
  dwg_wchar_t string[0];
  
} eed_data_t_eed_0_r2007;

typedef struct {
  BITCODE_RS appid_index;
  
  
  
  char invalid[0];
  
} eed_data_t_eed_1;

typedef struct {
  BITCODE_RC close;
} eed_data_t_eed_2;

typedef struct {
  BITCODE_RLL layer;
} eed_data_t_eed_3;

typedef struct {
  BITCODE_RC length;
  unsigned char data[] ;           
} eed_data_t_eed_4;

typedef struct {
  BITCODE_RLL entity;
} eed_data_t_eed_5;

typedef struct {
  BITCODE_3RD point;
} eed_data_t_eed_10;

typedef struct {
  BITCODE_RD real;
} eed_data_t_eed_40;

typedef struct {
  BITCODE_RS rs;
} eed_data_t_eed_70;

typedef struct {
  BITCODE_RL rl;
} eed_data_t_eed_71;


SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}

typedef union {
  Dwg_Entity_UNUSED *UNUSED;
  Dwg_DIMENSION_common *DIMENSION_common;
  
  
  
  Dwg_Entity__3DFACE *_3DFACE;
  Dwg_Entity__3DSOLID *_3DSOLID;
  Dwg_Entity_ARC *ARC;
  Dwg_Entity_ATTDEF *ATTDEF;
  Dwg_Entity_ATTRIB *ATTRIB;
  Dwg_Entity_BLOCK *BLOCK;
  Dwg_Entity_BODY *BODY;
  Dwg_Entity_CIRCLE *CIRCLE;
  Dwg_Entity_DIMENSION_ALIGNED *DIMENSION_ALIGNED;
  Dwg_Entity_DIMENSION_ANG2LN *DIMENSION_ANG2LN;
  Dwg_Entity_DIMENSION_ANG3PT *DIMENSION_ANG3PT;
  Dwg_Entity_DIMENSION_DIAMETER *DIMENSION_DIAMETER;
  Dwg_Entity_DIMENSION_LINEAR *DIMENSION_LINEAR;
  Dwg_Entity_DIMENSION_ORDINATE *DIMENSION_ORDINATE;
  Dwg_Entity_DIMENSION_RADIUS *DIMENSION_RADIUS;
  Dwg_Entity_ELLIPSE *ELLIPSE;
  Dwg_Entity_ENDBLK *ENDBLK;
  Dwg_Entity_INSERT *INSERT;
  Dwg_Entity_LEADER *LEADER;
  Dwg_Entity_LINE *LINE;
  Dwg_Entity_LOAD *LOAD;
  Dwg_Entity_MINSERT *MINSERT;
  Dwg_Entity_MLINE *MLINE;
  Dwg_Entity_MTEXT *MTEXT;
  Dwg_Entity_OLEFRAME *OLEFRAME;
  Dwg_Entity_POINT *POINT;
  Dwg_Entity_POLYLINE_2D *POLYLINE_2D;
  Dwg_Entity_POLYLINE_3D *POLYLINE_3D;
  Dwg_Entity_POLYLINE_MESH *POLYLINE_MESH;
  Dwg_Entity_POLYLINE_PFACE *POLYLINE_PFACE;
  Dwg_Entity_PROXY_ENTITY *PROXY_ENTITY;
  Dwg_Entity_RAY *RAY;
  Dwg_Entity_REGION *REGION;
  Dwg_Entity_SEQEND *SEQEND;
  Dwg_Entity_SHAPE *SHAPE;
  Dwg_Entity_SOLID *SOLID;
  Dwg_Entity_SPLINE *SPLINE;
  Dwg_Entity_TEXT *TEXT;
  Dwg_Entity_TOLERANCE *TOLERANCE;
  Dwg_Entity_TRACE *TRACE;
  Dwg_Entity_UNKNOWN_ENT *UNKNOWN_ENT;
  Dwg_Entity_VERTEX_2D *VERTEX_2D;
  Dwg_Entity_VERTEX_3D *VERTEX_3D;
  Dwg_Entity_VERTEX_MESH *VERTEX_MESH;
  Dwg_Entity_VERTEX_PFACE *VERTEX_PFACE;
  Dwg_Entity_VERTEX_PFACE_FACE *VERTEX_PFACE_FACE;
  Dwg_Entity_VIEWPORT *VIEWPORT;
  Dwg_Entity_XLINE *XLINE;
  
  Dwg_Entity__3DLINE *_3DLINE;
  Dwg_Entity_CAMERA *CAMERA;
  Dwg_Entity_DGNUNDERLAY *DGNUNDERLAY;
  Dwg_Entity_DWFUNDERLAY *DWFUNDERLAY;
  Dwg_Entity_ENDREP *ENDREP;
  Dwg_Entity_HATCH *HATCH;
  Dwg_Entity_IMAGE *IMAGE;
  Dwg_Entity_JUMP *JUMP;
  Dwg_Entity_LIGHT *LIGHT;
  Dwg_Entity_LWPOLYLINE *LWPOLYLINE;
  Dwg_Entity_MESH *MESH;
  Dwg_Entity_MULTILEADER *MULTILEADER;
  Dwg_Entity_OLE2FRAME *OLE2FRAME;
  Dwg_Entity_PDFUNDERLAY *PDFUNDERLAY;
  Dwg_Entity_REPEAT *REPEAT;
  Dwg_Entity_SECTIONOBJECT *SECTIONOBJECT;
  Dwg_Entity_WIPEOUT *WIPEOUT;
  
  Dwg_Entity_ARC_DIMENSION *ARC_DIMENSION;
  Dwg_Entity_HELIX *HELIX;
  Dwg_Entity_LARGE_RADIAL_DIMENSION *LARGE_RADIAL_DIMENSION;
  Dwg_Entity_LAYOUTPRINTCONFIG *LAYOUTPRINTCONFIG;
  Dwg_Entity_PLANESURFACE *PLANESURFACE;
  Dwg_Entity_POINTCLOUD *POINTCLOUD;
  Dwg_Entity_POINTCLOUDEX *POINTCLOUDEX;
  
  Dwg_Entity_ALIGNMENTPARAMETERENTITY *ALIGNMENTPARAMETERENTITY;
  Dwg_Entity_ARCALIGNEDTEXT *ARCALIGNEDTEXT;
  Dwg_Entity_BASEPOINTPARAMETERENTITY *BASEPOINTPARAMETERENTITY;
  Dwg_Entity_EXTRUDEDSURFACE *EXTRUDEDSURFACE;
  Dwg_Entity_FLIPGRIPENTITY *FLIPGRIPENTITY;
  Dwg_Entity_FLIPPARAMETERENTITY *FLIPPARAMETERENTITY;
  Dwg_Entity_GEOPOSITIONMARKER *GEOPOSITIONMARKER;
  Dwg_Entity_LINEARGRIPENTITY *LINEARGRIPENTITY;
  Dwg_Entity_LINEARPARAMETERENTITY *LINEARPARAMETERENTITY;
  Dwg_Entity_LOFTEDSURFACE *LOFTEDSURFACE;
  Dwg_Entity_MPOLYGON *MPOLYGON;
  Dwg_Entity_NAVISWORKSMODEL *NAVISWORKSMODEL;
  Dwg_Entity_NURBSURFACE *NURBSURFACE;
  Dwg_Entity_POINTPARAMETERENTITY *POINTPARAMETERENTITY;
  Dwg_Entity_POLARGRIPENTITY *POLARGRIPENTITY;
  Dwg_Entity_REVOLVEDSURFACE *REVOLVEDSURFACE;
  Dwg_Entity_ROTATIONGRIPENTITY *ROTATIONGRIPENTITY;
  Dwg_Entity_ROTATIONPARAMETERENTITY *ROTATIONPARAMETERENTITY;
  Dwg_Entity_RTEXT *RTEXT;
  Dwg_Entity_SWEPTSURFACE *SWEPTSURFACE;
  Dwg_Entity_TABLE *TABLE;
  Dwg_Entity_VISIBILITYGRIPENTITY *VISIBILITYGRIPENTITY;
  Dwg_Entity_VISIBILITYPARAMETERENTITY *VISIBILITYPARAMETERENTITY;
  Dwg_Entity_XYGRIPENTITY *XYGRIPENTITY;
  Dwg_Entity_XYPARAMETERENTITY *XYPARAMETERENTITY;
  
  
  
} _dwg_object_entity_tio;

typedef union {
  Dwg_Object_APPID *APPID;
  Dwg_Object_APPID_CONTROL *APPID_CONTROL;
  Dwg_Object_BLOCK_CONTROL *BLOCK_CONTROL;
  Dwg_Object_BLOCK_HEADER *BLOCK_HEADER;
  Dwg_Object_DICTIONARY *DICTIONARY;
  Dwg_Object_DIMSTYLE *DIMSTYLE;
  Dwg_Object_DIMSTYLE_CONTROL *DIMSTYLE_CONTROL;
  Dwg_Object_DUMMY *DUMMY;
  Dwg_Object_LAYER *LAYER;
  Dwg_Object_LAYER_CONTROL *LAYER_CONTROL;
  Dwg_Object_LONG_TRANSACTION *LONG_TRANSACTION;
  Dwg_Object_LTYPE *LTYPE;
  Dwg_Object_LTYPE_CONTROL *LTYPE_CONTROL;
  Dwg_Object_MLINESTYLE *MLINESTYLE;
  Dwg_Object_STYLE *STYLE;
  Dwg_Object_STYLE_CONTROL *STYLE_CONTROL;
  Dwg_Object_UCS *UCS;
  Dwg_Object_UCS_CONTROL *UCS_CONTROL;
  Dwg_Object_UNKNOWN_OBJ *UNKNOWN_OBJ;
  Dwg_Object_VIEW *VIEW;
  Dwg_Object_VIEW_CONTROL *VIEW_CONTROL;
  Dwg_Object_VPORT *VPORT;
  Dwg_Object_VPORT_CONTROL *VPORT_CONTROL;
  Dwg_Object_VX_CONTROL *VX_CONTROL;
  Dwg_Object_VX_TABLE_RECORD *VX_TABLE_RECORD;
  
  Dwg_Object_ACSH_BOOLEAN_CLASS *ACSH_BOOLEAN_CLASS;
  Dwg_Object_ACSH_BOX_CLASS *ACSH_BOX_CLASS;
  Dwg_Object_ACSH_CONE_CLASS *ACSH_CONE_CLASS;
  Dwg_Object_ACSH_CYLINDER_CLASS *ACSH_CYLINDER_CLASS;
  Dwg_Object_ACSH_FILLET_CLASS *ACSH_FILLET_CLASS;
  Dwg_Object_ACSH_HISTORY_CLASS *ACSH_HISTORY_CLASS;
  Dwg_Object_ACSH_SPHERE_CLASS *ACSH_SPHERE_CLASS;
  Dwg_Object_ACSH_TORUS_CLASS *ACSH_TORUS_CLASS;
  Dwg_Object_ACSH_WEDGE_CLASS *ACSH_WEDGE_CLASS;
  Dwg_Object_ASSOCGEOMDEPENDENCY *ASSOCGEOMDEPENDENCY;
  Dwg_Object_ASSOCNETWORK *ASSOCNETWORK;
  Dwg_Object_BLOCKALIGNMENTGRIP *BLOCKALIGNMENTGRIP;
  Dwg_Object_BLOCKALIGNMENTPARAMETER *BLOCKALIGNMENTPARAMETER;
  Dwg_Object_BLOCKBASEPOINTPARAMETER *BLOCKBASEPOINTPARAMETER;
  Dwg_Object_BLOCKFLIPACTION *BLOCKFLIPACTION;
  Dwg_Object_BLOCKFLIPGRIP *BLOCKFLIPGRIP;
  Dwg_Object_BLOCKFLIPPARAMETER *BLOCKFLIPPARAMETER;
  Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *BLOCKGRIPLOCATIONCOMPONENT;
  Dwg_Object_BLOCKLINEARGRIP *BLOCKLINEARGRIP;
  Dwg_Object_BLOCKLOOKUPGRIP *BLOCKLOOKUPGRIP;
  Dwg_Object_BLOCKMOVEACTION *BLOCKMOVEACTION;
  Dwg_Object_BLOCKROTATEACTION *BLOCKROTATEACTION;
  Dwg_Object_BLOCKROTATIONGRIP *BLOCKROTATIONGRIP;
  Dwg_Object_BLOCKSCALEACTION *BLOCKSCALEACTION;
  Dwg_Object_BLOCKVISIBILITYGRIP *BLOCKVISIBILITYGRIP;
  Dwg_Object_CELLSTYLEMAP *CELLSTYLEMAP;
  Dwg_Object_DETAILVIEWSTYLE *DETAILVIEWSTYLE;
  Dwg_Object_DICTIONARYVAR *DICTIONARYVAR;
  Dwg_Object_DICTIONARYWDFLT *DICTIONARYWDFLT;
  Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *DYNAMICBLOCKPURGEPREVENTER;
  Dwg_Object_FIELD *FIELD;
  Dwg_Object_FIELDLIST *FIELDLIST;
  Dwg_Object_GEODATA *GEODATA;
  Dwg_Object_GROUP *GROUP;
  Dwg_Object_IDBUFFER *IDBUFFER;
  Dwg_Object_IMAGEDEF *IMAGEDEF;
  Dwg_Object_IMAGEDEF_REACTOR *IMAGEDEF_REACTOR;
  Dwg_Object_INDEX *INDEX;
  Dwg_Object_LAYERFILTER *LAYERFILTER;
  Dwg_Object_LAYER_INDEX *LAYER_INDEX;
  Dwg_Object_LAYOUT *LAYOUT;
  Dwg_Object_PLACEHOLDER *PLACEHOLDER;
  Dwg_Object_PLOTSETTINGS *PLOTSETTINGS;
  Dwg_Object_RASTERVARIABLES *RASTERVARIABLES;
  Dwg_Object_RENDERENVIRONMENT *RENDERENVIRONMENT;
  Dwg_Object_SCALE *SCALE;
  Dwg_Object_SECTIONVIEWSTYLE *SECTIONVIEWSTYLE;
  Dwg_Object_SECTION_MANAGER *SECTION_MANAGER;
  Dwg_Object_SORTENTSTABLE *SORTENTSTABLE;
  Dwg_Object_SPATIAL_FILTER *SPATIAL_FILTER;
  Dwg_Object_SUN *SUN;
  Dwg_Object_TABLEGEOMETRY *TABLEGEOMETRY;
  Dwg_Object_VBA_PROJECT *VBA_PROJECT;
  Dwg_Object_VISUALSTYLE *VISUALSTYLE;
  Dwg_Object_WIPEOUTVARIABLES *WIPEOUTVARIABLES;
  Dwg_Object_XRECORD *XRECORD;
  Dwg_Object_PDFDEFINITION *PDFDEFINITION;
  Dwg_Object_DGNDEFINITION *DGNDEFINITION;
  Dwg_Object_DWFDEFINITION *DWFDEFINITION;
  
  Dwg_Object_ACSH_BREP_CLASS *ACSH_BREP_CLASS;
  Dwg_Object_ACSH_CHAMFER_CLASS *ACSH_CHAMFER_CLASS;
  Dwg_Object_ACSH_PYRAMID_CLASS *ACSH_PYRAMID_CLASS;
  Dwg_Object_ALDIMOBJECTCONTEXTDATA *ALDIMOBJECTCONTEXTDATA;
  Dwg_Object_ASSOC2DCONSTRAINTGROUP *ASSOC2DCONSTRAINTGROUP;
  Dwg_Object_ASSOCACTION *ASSOCACTION;
  Dwg_Object_ASSOCACTIONPARAM *ASSOCACTIONPARAM;
  Dwg_Object_ASSOCARRAYACTIONBODY *ASSOCARRAYACTIONBODY;
  Dwg_Object_ASSOCASMBODYACTIONPARAM *ASSOCASMBODYACTIONPARAM;
  Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *ASSOCBLENDSURFACEACTIONBODY;
  Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *ASSOCCOMPOUNDACTIONPARAM;
  Dwg_Object_ASSOCDEPENDENCY *ASSOCDEPENDENCY;
  Dwg_Object_ASSOCDIMDEPENDENCYBODY *ASSOCDIMDEPENDENCYBODY;
  Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *ASSOCEXTENDSURFACEACTIONBODY;
  Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *ASSOCEXTRUDEDSURFACEACTIONBODY;
  Dwg_Object_ASSOCFACEACTIONPARAM *ASSOCFACEACTIONPARAM;
  Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *ASSOCFILLETSURFACEACTIONBODY;
  Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *ASSOCLOFTEDSURFACEACTIONBODY;
  Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *ASSOCNETWORKSURFACEACTIONBODY;
  Dwg_Object_ASSOCOBJECTACTIONPARAM *ASSOCOBJECTACTIONPARAM;
  Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *ASSOCOFFSETSURFACEACTIONBODY;
  Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *ASSOCOSNAPPOINTREFACTIONPARAM;
  Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *ASSOCPATCHSURFACEACTIONBODY;
  Dwg_Object_ASSOCPATHACTIONPARAM *ASSOCPATHACTIONPARAM;
  Dwg_Object_ASSOCPLANESURFACEACTIONBODY *ASSOCPLANESURFACEACTIONBODY;
  Dwg_Object_ASSOCPOINTREFACTIONPARAM *ASSOCPOINTREFACTIONPARAM;
  Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *ASSOCREVOLVEDSURFACEACTIONBODY;
  Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *ASSOCTRIMSURFACEACTIONBODY;
  Dwg_Object_ASSOCVALUEDEPENDENCY *ASSOCVALUEDEPENDENCY;
  Dwg_Object_ASSOCVARIABLE *ASSOCVARIABLE;
  Dwg_Object_ASSOCVERTEXACTIONPARAM *ASSOCVERTEXACTIONPARAM;
  Dwg_Object_BLKREFOBJECTCONTEXTDATA *BLKREFOBJECTCONTEXTDATA;
  Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *BLOCKALIGNEDCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *BLOCKANGULARCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKARRAYACTION *BLOCKARRAYACTION;
  Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *BLOCKDIAMETRICCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *BLOCKHORIZONTALCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *BLOCKLINEARCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKLINEARPARAMETER *BLOCKLINEARPARAMETER;
  Dwg_Object_BLOCKLOOKUPACTION *BLOCKLOOKUPACTION;
  Dwg_Object_BLOCKLOOKUPPARAMETER *BLOCKLOOKUPPARAMETER;
  Dwg_Object_BLOCKPARAMDEPENDENCYBODY *BLOCKPARAMDEPENDENCYBODY;
  Dwg_Object_BLOCKPOINTPARAMETER *BLOCKPOINTPARAMETER;
  Dwg_Object_BLOCKPOLARGRIP *BLOCKPOLARGRIP;
  Dwg_Object_BLOCKPOLARPARAMETER *BLOCKPOLARPARAMETER;
  Dwg_Object_BLOCKPOLARSTRETCHACTION *BLOCKPOLARSTRETCHACTION;
  Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *BLOCKRADIALCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKREPRESENTATION *BLOCKREPRESENTATION;
  Dwg_Object_BLOCKROTATIONPARAMETER *BLOCKROTATIONPARAMETER;
  Dwg_Object_BLOCKSTRETCHACTION *BLOCKSTRETCHACTION;
  Dwg_Object_BLOCKUSERPARAMETER *BLOCKUSERPARAMETER;
  Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *BLOCKVERTICALCONSTRAINTPARAMETER;
  Dwg_Object_BLOCKVISIBILITYPARAMETER *BLOCKVISIBILITYPARAMETER;
  Dwg_Object_BLOCKXYGRIP *BLOCKXYGRIP;
  Dwg_Object_BLOCKXYPARAMETER *BLOCKXYPARAMETER;
  Dwg_Object_DATALINK *DATALINK;
  Dwg_Object_DBCOLOR *DBCOLOR;
  Dwg_Object_EVALUATION_GRAPH *EVALUATION_GRAPH;
  Dwg_Object_FCFOBJECTCONTEXTDATA *FCFOBJECTCONTEXTDATA;
  Dwg_Object_GRADIENT_BACKGROUND *GRADIENT_BACKGROUND;
  Dwg_Object_GROUND_PLANE_BACKGROUND *GROUND_PLANE_BACKGROUND;
  Dwg_Object_IBL_BACKGROUND *IBL_BACKGROUND;
  Dwg_Object_IMAGE_BACKGROUND *IMAGE_BACKGROUND;
  Dwg_Object_LEADEROBJECTCONTEXTDATA *LEADEROBJECTCONTEXTDATA;
  Dwg_Object_LIGHTLIST *LIGHTLIST;
  Dwg_Object_MATERIAL *MATERIAL;
  Dwg_Object_MENTALRAYRENDERSETTINGS *MENTALRAYRENDERSETTINGS;
  Dwg_Object_MLEADERSTYLE *MLEADERSTYLE;
  Dwg_Object_MTEXTOBJECTCONTEXTDATA *MTEXTOBJECTCONTEXTDATA;
  Dwg_Object_OBJECT_PTR *OBJECT_PTR;
  Dwg_Object_PARTIAL_VIEWING_INDEX *PARTIAL_VIEWING_INDEX;
  Dwg_Object_POINTCLOUDCOLORMAP *POINTCLOUDCOLORMAP;
  Dwg_Object_POINTCLOUDDEF *POINTCLOUDDEF;
  Dwg_Object_POINTCLOUDDEFEX *POINTCLOUDDEFEX;
  Dwg_Object_POINTCLOUDDEF_REACTOR *POINTCLOUDDEF_REACTOR;
  Dwg_Object_POINTCLOUDDEF_REACTOR_EX *POINTCLOUDDEF_REACTOR_EX;
  Dwg_Object_PROXY_OBJECT *PROXY_OBJECT;
  Dwg_Object_RAPIDRTRENDERSETTINGS *RAPIDRTRENDERSETTINGS;
  Dwg_Object_RENDERENTRY *RENDERENTRY;
  Dwg_Object_RENDERGLOBAL *RENDERGLOBAL;
  Dwg_Object_RENDERSETTINGS *RENDERSETTINGS;
  Dwg_Object_SECTION_SETTINGS *SECTION_SETTINGS;
  Dwg_Object_SKYLIGHT_BACKGROUND *SKYLIGHT_BACKGROUND;
  Dwg_Object_SOLID_BACKGROUND *SOLID_BACKGROUND;
  Dwg_Object_SPATIAL_INDEX *SPATIAL_INDEX;
  Dwg_Object_TABLESTYLE *TABLESTYLE;
  Dwg_Object_TEXTOBJECTCONTEXTDATA *TEXTOBJECTCONTEXTDATA;
  Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *ASSOCARRAYMODIFYPARAMETERS;
  Dwg_Object_ASSOCARRAYPATHPARAMETERS *ASSOCARRAYPATHPARAMETERS;
  Dwg_Object_ASSOCARRAYPOLARPARAMETERS *ASSOCARRAYPOLARPARAMETERS;
  Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *ASSOCARRAYRECTANGULARPARAMETERS;
  
  Dwg_Object_ACMECOMMANDHISTORY *ACMECOMMANDHISTORY;
  Dwg_Object_ACMESCOPE *ACMESCOPE;
  Dwg_Object_ACMESTATEMGR *ACMESTATEMGR;
  Dwg_Object_ACSH_EXTRUSION_CLASS *ACSH_EXTRUSION_CLASS;
  Dwg_Object_ACSH_LOFT_CLASS *ACSH_LOFT_CLASS;
  Dwg_Object_ACSH_REVOLVE_CLASS *ACSH_REVOLVE_CLASS;
  Dwg_Object_ACSH_SWEEP_CLASS *ACSH_SWEEP_CLASS;
  Dwg_Object_ANGDIMOBJECTCONTEXTDATA *ANGDIMOBJECTCONTEXTDATA;
  Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *ANNOTSCALEOBJECTCONTEXTDATA;
  Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *ASSOC3POINTANGULARDIMACTIONBODY;
  Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *ASSOCALIGNEDDIMACTIONBODY;
  Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *ASSOCARRAYMODIFYACTIONBODY;
  Dwg_Object_ASSOCEDGEACTIONPARAM *ASSOCEDGEACTIONPARAM;
  Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *ASSOCEDGECHAMFERACTIONBODY;
  Dwg_Object_ASSOCEDGEFILLETACTIONBODY *ASSOCEDGEFILLETACTIONBODY;
  Dwg_Object_ASSOCMLEADERACTIONBODY *ASSOCMLEADERACTIONBODY;
  Dwg_Object_ASSOCORDINATEDIMACTIONBODY *ASSOCORDINATEDIMACTIONBODY;
  Dwg_Object_ASSOCPERSSUBENTMANAGER *ASSOCPERSSUBENTMANAGER;
  Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *ASSOCRESTOREENTITYSTATEACTIONBODY;
  Dwg_Object_ASSOCROTATEDDIMACTIONBODY *ASSOCROTATEDDIMACTIONBODY;
  Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *ASSOCSWEPTSURFACEACTIONBODY;
  Dwg_Object_BLOCKPROPERTIESTABLE *BLOCKPROPERTIESTABLE;
  Dwg_Object_BLOCKPROPERTIESTABLEGRIP *BLOCKPROPERTIESTABLEGRIP;
  Dwg_Object_BREAKDATA *BREAKDATA;
  Dwg_Object_BREAKPOINTREF *BREAKPOINTREF;
  Dwg_Object_CONTEXTDATAMANAGER *CONTEXTDATAMANAGER;
  Dwg_Object_CSACDOCUMENTOPTIONS *CSACDOCUMENTOPTIONS;
  Dwg_Object_CURVEPATH *CURVEPATH;
  Dwg_Object_DATATABLE *DATATABLE;
  Dwg_Object_DIMASSOC *DIMASSOC;
  Dwg_Object_DMDIMOBJECTCONTEXTDATA *DMDIMOBJECTCONTEXTDATA;
  Dwg_Object_DYNAMICBLOCKPROXYNODE *DYNAMICBLOCKPROXYNODE;
  Dwg_Object_GEOMAPIMAGE *GEOMAPIMAGE;
  Dwg_Object_MLEADEROBJECTCONTEXTDATA *MLEADEROBJECTCONTEXTDATA;
  Dwg_Object_MOTIONPATH *MOTIONPATH;
  Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *MTEXTATTRIBUTEOBJECTCONTEXTDATA;
  Dwg_Object_NAVISWORKSMODELDEF *NAVISWORKSMODELDEF;
  Dwg_Object_ORDDIMOBJECTCONTEXTDATA *ORDDIMOBJECTCONTEXTDATA;
  Dwg_Object_PERSUBENTMGR *PERSUBENTMGR;
  Dwg_Object_POINTPATH *POINTPATH;
  Dwg_Object_RADIMLGOBJECTCONTEXTDATA *RADIMLGOBJECTCONTEXTDATA;
  Dwg_Object_RADIMOBJECTCONTEXTDATA *RADIMOBJECTCONTEXTDATA;
  Dwg_Object_SUNSTUDY *SUNSTUDY;
  Dwg_Object_TABLECONTENT *TABLECONTENT;
  Dwg_Object_TVDEVICEPROPERTIES *TVDEVICEPROPERTIES;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
} _dwg_object_object_tio;


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  ((unsigned long)(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  ((unsigned long long)(value));
  }
#endif
}

typedef union {
  Dwg_Object_Entity *entity;
  Dwg_Object_Object *object;
} _dwg_object_tio;


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong((long)(value));
}
#endif

typedef union {
  Dwg_R2004_Header r2004_header;                        
  Dwg_R2007_Header r2007_file_header;                        
} _dwg_struct_fhdr;


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_Dwg_Object_Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Dwg_Object_Array" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  result = (Dwg_Object *)new_Dwg_Object_Array(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_Array" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  delete_Dwg_Object_Array(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Array_getitem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Array_getitem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Array_getitem" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Array_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  result = Dwg_Object_Array_getitem(arg1,arg2);
  resultobj = SWIG_NewPointerObj((Dwg_Object *)memcpy((Dwg_Object *)calloc(1,sizeof(Dwg_Object)),&result,sizeof(Dwg_Object)), SWIGTYPE_p__dwg_object, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Array_setitem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  size_t arg2 ;
  Dwg_Object arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Array_setitem", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Array_setitem" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Array_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p__dwg_object,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Dwg_Object_Array_setitem" "', argument " "3"" of type '" "Dwg_Object""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Dwg_Object_Array_setitem" "', argument " "3"" of type '" "Dwg_Object""'");
    } else {
      arg3 = *((Dwg_Object *)(argp3));
    }
  }
  Dwg_Object_Array_setitem(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_days_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_TimeBLL_days_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_days_set" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_TimeBLL_days_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->days = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_days_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_days_get" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  result = (BITCODE_BL) ((arg1)->days);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_ms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_TimeBLL_ms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_ms_set" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_TimeBLL_ms_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->ms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_ms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_ms_get" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  result = (BITCODE_BL) ((arg1)->ms);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_TimeBLL_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_value_set" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_TimeBLL_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_TimeBLL_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_TimeBLL_value_get" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  result = (BITCODE_BD) ((arg1)->value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Bitcode_TimeBLL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Bitcode_TimeBLL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_time_bll *)calloc(1, sizeof(struct _dwg_time_bll));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Bitcode_TimeBLL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_time_bll *arg1 = (struct _dwg_time_bll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_time_bll, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Bitcode_TimeBLL" "', argument " "1"" of type '" "struct _dwg_time_bll *""'"); 
  }
  arg1 = (struct _dwg_time_bll *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Bitcode_TimeBLL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_time_bll, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Bitcode_TimeBLL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2RD_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *arg1 = (struct _dwg_bitcode_2rd *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_2RD_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2RD_x_set" "', argument " "1"" of type '" "struct _dwg_bitcode_2rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2rd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_2RD_x_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2RD_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *arg1 = (struct _dwg_bitcode_2rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2RD_x_get" "', argument " "1"" of type '" "struct _dwg_bitcode_2rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2rd *)(argp1);
  result = (BITCODE_RD) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2RD_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *arg1 = (struct _dwg_bitcode_2rd *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_2RD_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2RD_y_set" "', argument " "1"" of type '" "struct _dwg_bitcode_2rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2rd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_2RD_y_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2RD_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *arg1 = (struct _dwg_bitcode_2rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2RD_y_get" "', argument " "1"" of type '" "struct _dwg_bitcode_2rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2rd *)(argp1);
  result = (BITCODE_RD) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Bitcode_2RD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Bitcode_2RD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_bitcode_2rd *)calloc(1, sizeof(struct _dwg_bitcode_2rd));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Bitcode_2RD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2rd *arg1 = (struct _dwg_bitcode_2rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Bitcode_2RD" "', argument " "1"" of type '" "struct _dwg_bitcode_2rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2rd *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Bitcode_2RD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_bitcode_2rd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Bitcode_2RD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2BD_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *arg1 = (struct _dwg_bitcode_2bd *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_2BD_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2BD_x_set" "', argument " "1"" of type '" "struct _dwg_bitcode_2bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2bd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_2BD_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2BD_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *arg1 = (struct _dwg_bitcode_2bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2BD_x_get" "', argument " "1"" of type '" "struct _dwg_bitcode_2bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2bd *)(argp1);
  result = (BITCODE_BD) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2BD_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *arg1 = (struct _dwg_bitcode_2bd *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_2BD_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2BD_y_set" "', argument " "1"" of type '" "struct _dwg_bitcode_2bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2bd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_2BD_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_2BD_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *arg1 = (struct _dwg_bitcode_2bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_2BD_y_get" "', argument " "1"" of type '" "struct _dwg_bitcode_2bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2bd *)(argp1);
  result = (BITCODE_BD) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Bitcode_2BD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Bitcode_2BD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_bitcode_2bd *)calloc(1, sizeof(struct _dwg_bitcode_2bd));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Bitcode_2BD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_2bd *arg1 = (struct _dwg_bitcode_2bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_2bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Bitcode_2BD" "', argument " "1"" of type '" "struct _dwg_bitcode_2bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_2bd *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Bitcode_2BD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_bitcode_2bd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Bitcode_2BD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3RD_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_x_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3RD_x_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_x_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  result = (BITCODE_RD) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3RD_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_y_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3RD_y_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_y_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  result = (BITCODE_RD) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3RD_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_z_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3RD_z_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3RD_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3RD_z_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  result = (BITCODE_RD) ((arg1)->z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Bitcode_3RD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Bitcode_3RD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_bitcode_3rd *)calloc(1, sizeof(struct _dwg_bitcode_3rd));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Bitcode_3RD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3rd *arg1 = (struct _dwg_bitcode_3rd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Bitcode_3RD" "', argument " "1"" of type '" "struct _dwg_bitcode_3rd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3rd *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Bitcode_3RD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_bitcode_3rd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Bitcode_3RD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3BD_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_x_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3BD_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_x_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  result = (BITCODE_BD) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3BD_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_y_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3BD_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_y_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  result = (BITCODE_BD) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Bitcode_3BD_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_z_set" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Bitcode_3BD_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Bitcode_3BD_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Bitcode_3BD_z_get" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  result = (BITCODE_BD) ((arg1)->z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Bitcode_3BD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Bitcode_3BD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_bitcode_3bd *)calloc(1, sizeof(struct _dwg_bitcode_3bd));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Bitcode_3BD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_bitcode_3bd *arg1 = (struct _dwg_bitcode_3bd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Bitcode_3BD" "', argument " "1"" of type '" "struct _dwg_bitcode_3bd *""'"); 
  }
  arg1 = (struct _dwg_bitcode_3bd *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Bitcode_3BD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_bitcode_3bd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Bitcode_3BD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Versions_r_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  Dwg_Version_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Versions_r_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_r_set" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Versions_r_set" "', argument " "2"" of type '" "Dwg_Version_Type""'");
  } 
  arg2 = (Dwg_Version_Type)(val2);
  if (arg1) (arg1)->r = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_r_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Version_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_r_get" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  result = (Dwg_Version_Type) ((arg1)->r);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_type_get" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  result = (char *)(char *) ((arg1)->type);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_hdr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_hdr_get" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  result = (char *)(char *) ((arg1)->hdr);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_desc_get" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  result = (char *)(char *) ((arg1)->desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Versions_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_dwg_version_set" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Versions_dwg_version_set" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = (uint8_t)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Versions_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint8_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Versions_dwg_version_get" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  result = (uint8_t) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Versions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Versions", 0, 0, 0)) SWIG_fail;
  result = (struct dwg_versions *)calloc(1, sizeof(struct dwg_versions));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_versions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Versions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_versions *arg1 = (struct dwg_versions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_versions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Versions" "', argument " "1"" of type '" "struct dwg_versions *""'"); 
  }
  arg1 = (struct dwg_versions *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Versions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_dwg_versions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Versions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Handle_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Handle_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_code_set" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Handle_code_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_code_get" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  result = (BITCODE_RC) ((arg1)->code);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Handle_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_size_set" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Handle_size_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_size_get" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  result = (BITCODE_RC) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  BITCODE_HV arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Handle_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_value_set" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Handle_value_set" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_HV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_value_get" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  result = (BITCODE_HV) ((arg1)->value);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_is_global_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Handle_is_global_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_is_global_set" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Handle_is_global_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_global = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Handle_is_global_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Handle_is_global_get" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  result = (BITCODE_B) ((arg1)->is_global);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Handle", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_handle *)calloc(1, sizeof(struct _dwg_handle));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_handle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_handle *arg1 = (struct _dwg_handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Handle" "', argument " "1"" of type '" "struct _dwg_handle *""'"); 
  }
  arg1 = (struct _dwg_handle *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Handle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_handle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Handle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_obj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  struct _dwg_object *arg2 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Ref_obj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_obj_set" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Ref_obj_set" "', argument " "2"" of type '" "struct _dwg_object *""'"); 
  }
  arg2 = (struct _dwg_object *)(argp2);
  if (arg1) (arg1)->obj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_obj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_obj_get" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  result = (struct _dwg_object *) ((arg1)->obj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_handleref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  Dwg_Handle *arg2 = (Dwg_Handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Ref_handleref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_handleref_set" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Ref_handleref_set" "', argument " "2"" of type '" "Dwg_Handle *""'"); 
  }
  arg2 = (Dwg_Handle *)(argp2);
  if (arg1) (arg1)->handleref = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_handleref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Handle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_handleref_get" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  result = (Dwg_Handle *)& ((arg1)->handleref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_handle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_absolute_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Ref_absolute_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_absolute_ref_set" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Ref_absolute_ref_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->absolute_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_absolute_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_absolute_ref_get" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  result = (BITCODE_RLL) ((arg1)->absolute_ref);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_r11_idx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Ref_r11_idx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_r11_idx_set" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Ref_r11_idx_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->r11_idx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Ref_r11_idx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Ref_r11_idx_get" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  result = (BITCODE_RSd) ((arg1)->r11_idx);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_Ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_Ref", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ref *)calloc(1, sizeof(struct _dwg_object_ref));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_Ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ref *arg1 = (struct _dwg_object_ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_Ref" "', argument " "1"" of type '" "struct _dwg_object_ref *""'"); 
  }
  arg1 = (struct _dwg_object_ref *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_Ref_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ref, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_Ref_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Color_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_index_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_index_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_index_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BSd) ((arg1)->index);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_flag_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_flag_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_raw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_raw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_raw_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_raw_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->raw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_raw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_raw_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BS) ((arg1)->raw);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_rgb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_rgb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_rgb_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_rgb_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->rgb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_rgb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_rgb_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BL) ((arg1)->rgb);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_method_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  Dwg_Color_Method arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_method_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_method_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_method_set" "', argument " "2"" of type '" "Dwg_Color_Method""'");
  } 
  arg2 = (Dwg_Color_Method)(val2);
  if (arg1) (arg1)->method = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_method_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Color_Method result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_method_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (Dwg_Color_Method) ((arg1)->method);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_name_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Color_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_name_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_book_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_book_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_book_name_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Color_book_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->book_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->book_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->book_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_book_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_book_name_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_TV) ((arg1)->book_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_handle_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Color_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_handle_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_raw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_alpha_raw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_raw_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_alpha_raw_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->alpha_raw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_raw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_raw_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BL) ((arg1)->alpha_raw);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_alpha_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_type_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_alpha_type_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->alpha_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_type_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_BB) ((arg1)->alpha_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Color_alpha_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_set" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Color_alpha_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->alpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Color_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Color_alpha_get" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  result = (BITCODE_RC) ((arg1)->alpha);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Color", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_color *)calloc(1, sizeof(struct _dwg_color));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_color *arg1 = (struct _dwg_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_color, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Color" "', argument " "1"" of type '" "struct _dwg_color *""'"); 
  }
  arg1 = (struct _dwg_color *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Color_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_color, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Color_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_dwg_color_method_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_color_method_name" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  result = (char *)dwg_color_method_name(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_binary_chunk_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_size_set" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_binary_chunk_size_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = (unsigned short)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_size_get" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  result = (unsigned short) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_codepage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_binary_chunk_codepage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_codepage_set" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_binary_chunk_codepage_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->codepage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_codepage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_codepage_get" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  result = (unsigned int) ((arg1)->codepage);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_is_tu_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_binary_chunk_is_tu_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_is_tu_set" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_binary_chunk_is_tu_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->is_tu = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_is_tu_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_is_tu_get" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  result = (unsigned int) ((arg1)->is_tu);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_binary_chunk_u *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_u_get" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  result = (_dwg_binary_chunk_u *)& ((arg1)->u);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_binary_chunk_u, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_binary_chunk(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_binary_chunk", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_binary_chunk *)calloc(1, sizeof(struct _dwg_binary_chunk));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_binary_chunk, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_binary_chunk(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_binary_chunk *arg1 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_binary_chunk" "', argument " "1"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg1 = (struct _dwg_binary_chunk *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_binary_chunk_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_binary_chunk, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_binary_chunk_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_binary_chunk_u_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *arg1 = (_dwg_binary_chunk_u *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_binary_chunk_u_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_u_data_set" "', argument " "1"" of type '" "_dwg_binary_chunk_u *""'"); 
  }
  arg1 = (_dwg_binary_chunk_u *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_binary_chunk_u_data_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->data);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->data = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->data = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_u_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *arg1 = (_dwg_binary_chunk_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_u_data_get" "', argument " "1"" of type '" "_dwg_binary_chunk_u *""'"); 
  }
  arg1 = (_dwg_binary_chunk_u *)(argp1);
  result = (char *) ((arg1)->data);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_u_wdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *arg1 = (_dwg_binary_chunk_u *) 0 ;
  dwg_wchar_t *arg2 = (dwg_wchar_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_binary_chunk_u_wdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_u_wdata_set" "', argument " "1"" of type '" "_dwg_binary_chunk_u *""'"); 
  }
  arg1 = (_dwg_binary_chunk_u *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_binary_chunk_u_wdata_set" "', argument " "2"" of type '" "dwg_wchar_t *""'"); 
  }
  arg2 = (dwg_wchar_t *)(argp2);
  if (arg1) (arg1)->wdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_binary_chunk_u_wdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *arg1 = (_dwg_binary_chunk_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  dwg_wchar_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_binary_chunk_u_wdata_get" "', argument " "1"" of type '" "_dwg_binary_chunk_u *""'"); 
  }
  arg1 = (_dwg_binary_chunk_u *)(argp1);
  result = (dwg_wchar_t *) ((arg1)->wdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_binary_chunk_u(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_binary_chunk_u", 0, 0, 0)) SWIG_fail;
  result = (_dwg_binary_chunk_u *)calloc(1, sizeof(_dwg_binary_chunk_u));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_binary_chunk_u, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_binary_chunk_u(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_binary_chunk_u *arg1 = (_dwg_binary_chunk_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_binary_chunk_u, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_binary_chunk_u" "', argument " "1"" of type '" "_dwg_binary_chunk_u *""'"); 
  }
  arg1 = (_dwg_binary_chunk_u *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_binary_chunk_u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_binary_chunk_u, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_binary_chunk_u_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Resbuf_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Resbuf_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Resbuf_type_set" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Resbuf_type_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Resbuf_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Resbuf_type_get" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  result = (short) ((arg1)->type);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Resbuf_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_resbuf_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Resbuf_value_get" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  result = (_dwg_resbuf_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Resbuf_nextrb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  struct _dwg_resbuf *arg2 = (struct _dwg_resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Resbuf_nextrb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Resbuf_nextrb_set" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_resbuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Resbuf_nextrb_set" "', argument " "2"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg2 = (struct _dwg_resbuf *)(argp2);
  if (arg1) (arg1)->nextrb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Resbuf_nextrb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_resbuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Resbuf_nextrb_get" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  result = (struct _dwg_resbuf *) ((arg1)->nextrb);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Resbuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Resbuf", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_resbuf *)calloc(1, sizeof(struct _dwg_resbuf));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_resbuf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Resbuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_resbuf *arg1 = (struct _dwg_resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Resbuf" "', argument " "1"" of type '" "struct _dwg_resbuf *""'"); 
  }
  arg1 = (struct _dwg_resbuf *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Resbuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_resbuf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Resbuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_resbuf_value_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  double *arg2 = (double *) (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_pt_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_resbuf_value_pt_set" "', argument " "2"" of type '" "double [3]""'"); 
  } 
  arg2 = (double *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(double *)&arg1->pt[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""pt""' of type '""double [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_pt_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (double *)(double *) ((arg1)->pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i8_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_i8_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i8_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_i8_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  if (arg1) (arg1)->i8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i8_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i8_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (char) ((arg1)->i8);
  resultobj = SWIG_From_char((char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i16_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_i16_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i16_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_i16_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  if (arg1) (arg1)->i16 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i16_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i16_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (short) ((arg1)->i16);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_i32_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i32_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_i32_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->i32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i32_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (int) ((arg1)->i32);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i64_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_i64_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i64_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_i64_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->i64 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_i64_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_i64_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (BITCODE_BLL) ((arg1)->i64);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_absref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  BITCODE_HV arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_absref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_absref_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_absref_set" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  if (arg1) (arg1)->absref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_absref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_HV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_absref_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (BITCODE_HV) ((arg1)->absref);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_dbl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_dbl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_dbl_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_resbuf_value_dbl_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->dbl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_dbl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_dbl_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (double) ((arg1)->dbl);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_str_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  struct _dwg_binary_chunk *arg2 = (struct _dwg_binary_chunk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_resbuf_value_str_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_str_set" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_resbuf_value_str_set" "', argument " "2"" of type '" "struct _dwg_binary_chunk *""'"); 
  }
  arg2 = (struct _dwg_binary_chunk *)(argp2);
  if (arg1) (arg1)->str = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_resbuf_value_str_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_binary_chunk *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_resbuf_value_str_get" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  result = (struct _dwg_binary_chunk *)& ((arg1)->str);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_binary_chunk, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_resbuf_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_resbuf_value", 0, 0, 0)) SWIG_fail;
  result = (_dwg_resbuf_value *)calloc(1, sizeof(_dwg_resbuf_value));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_resbuf_value, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_resbuf_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_resbuf_value *arg1 = (_dwg_resbuf_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_resbuf_value, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_resbuf_value" "', argument " "1"" of type '" "_dwg_resbuf_value *""'"); 
  }
  arg1 = (_dwg_resbuf_value *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_resbuf_value_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_resbuf_value, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_resbuf_value_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_size_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_size_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_bitsize_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_bitsize_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_bitsize_hi_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_bitsize_hi_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->bitsize_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_bitsize_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_bitsize_hi_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->bitsize_hi);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_bitsize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_bitsize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_bitsize_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_bitsize_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->bitsize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_bitsize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_bitsize_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->bitsize);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ACADMAINTVER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ACADMAINTVER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ACADMAINTVER_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ACADMAINTVER_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->ACADMAINTVER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ACADMAINTVER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ACADMAINTVER_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->ACADMAINTVER);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REQUIREDVERSIONS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_REQUIREDVERSIONS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REQUIREDVERSIONS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_REQUIREDVERSIONS_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->REQUIREDVERSIONS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REQUIREDVERSIONS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REQUIREDVERSIONS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BLL) ((arg1)->REQUIREDVERSIONS);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DWGCODEPAGE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DWGCODEPAGE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DWGCODEPAGE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DWGCODEPAGE_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DWGCODEPAGE);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DWGCODEPAGE = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DWGCODEPAGE = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DWGCODEPAGE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DWGCODEPAGE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DWGCODEPAGE);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_codepage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_codepage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_codepage_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_codepage_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->codepage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_codepage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_codepage_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->codepage);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit1_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit1_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit1_ratio_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unit1_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit1_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit1_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit1_ratio_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit1_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit2_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit2_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit2_ratio_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unit2_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit2_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit2_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit2_ratio_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit2_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit3_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit3_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit3_ratio_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unit3_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit3_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit3_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit3_ratio_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit3_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit4_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit4_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit4_ratio_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unit4_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit4_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit4_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit4_ratio_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit4_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit1_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit1_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit1_name_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unit1_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unit1_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unit1_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unit1_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit1_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit1_name_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->unit1_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit2_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit2_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit2_name_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unit2_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unit2_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unit2_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unit2_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit2_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit2_name_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->unit2_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit3_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit3_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit3_name_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unit3_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unit3_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unit3_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unit3_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit3_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit3_name_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->unit3_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit4_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unit4_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit4_name_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unit4_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unit4_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unit4_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unit4_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unit4_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unit4_name_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->unit4_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_8_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_8_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_8_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_8_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_8_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_8_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_8);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_9_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_9_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_9_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_9_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_9 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_9_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_9_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_9);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_10_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_10_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_10_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_10_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_10 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_10_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_10_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_10);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VX_TABLE_RECORD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VX_TABLE_RECORD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VX_TABLE_RECORD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VX_TABLE_RECORD_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->VX_TABLE_RECORD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VX_TABLE_RECORD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VX_TABLE_RECORD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->VX_TABLE_RECORD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMASO_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASO_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMASO_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMASO = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASO_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMASO);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSHO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSHO_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSHO_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSHO_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSHO = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSHO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSHO_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSHO);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSAV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSAV_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSAV_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSAV_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSAV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSAV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSAV_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSAV);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLINEGEN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PLINEGEN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLINEGEN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PLINEGEN_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->PLINEGEN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLINEGEN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLINEGEN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->PLINEGEN);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ORTHOMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ORTHOMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ORTHOMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ORTHOMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ORTHOMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ORTHOMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ORTHOMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->ORTHOMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REGENMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_REGENMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REGENMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_REGENMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->REGENMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REGENMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REGENMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->REGENMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FILLMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FILLMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FILLMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FILLMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->FILLMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FILLMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FILLMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->FILLMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_QTEXTMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_QTEXTMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_QTEXTMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_QTEXTMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->QTEXTMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_QTEXTMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_QTEXTMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->QTEXTMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSLTSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PSLTSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSLTSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PSLTSCALE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->PSLTSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSLTSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSLTSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->PSLTSCALE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMCHECK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LIMCHECK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMCHECK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LIMCHECK_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->LIMCHECK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMCHECK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMCHECK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->LIMCHECK);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MENUEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_MENUEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MENUEXT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_MENUEXT_set" "', argument " "2"" of type '" "BITCODE_RC [46]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)46; ++ii) *(BITCODE_RC *)&arg1->MENUEXT[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""MENUEXT""' of type '""BITCODE_RC [46]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MENUEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MENUEXT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->MENUEXT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLIPMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_BLIPMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLIPMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_BLIPMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->BLIPMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLIPMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLIPMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->BLIPMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_11_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_11_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_11_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_11);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USRTIMER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USRTIMER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USRTIMER_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USRTIMER_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->USRTIMER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USRTIMER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USRTIMER_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->USRTIMER);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FASTZOOM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FASTZOOM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FASTZOOM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FASTZOOM_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->FASTZOOM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FASTZOOM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FASTZOOM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->FASTZOOM);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FLATLAND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FLATLAND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FLATLAND_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FLATLAND_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->FLATLAND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FLATLAND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FLATLAND_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->FLATLAND);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEWMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_VIEWMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->VIEWMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->VIEWMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SKPOLY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SKPOLY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SKPOLY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SKPOLY_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->SKPOLY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SKPOLY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SKPOLY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->SKPOLY);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_mon_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_mon_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_mon_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_mon_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_mon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_mon_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_mon_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_mon);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_day_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_day_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_day_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_day_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_day = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_day_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_day_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_day);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_year_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_year_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_year_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_year_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_year = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_year_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_year_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_year);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_hour_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_hour_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_hour_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_hour_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_hour = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_hour_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_hour_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_hour);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_min_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_min_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_min_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_min);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_sec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_sec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_sec_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_sec_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_sec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_sec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_sec_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_sec);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_ms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_ms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_ms_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_ms_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_ms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_ms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_ms_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_ms);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ANGDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ANGDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ANGDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ANGDIR_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ANGDIR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ANGDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ANGDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->ANGDIR);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SPLFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLFRAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SPLFRAME_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->SPLFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLFRAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->SPLFRAME);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTREQ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ATTREQ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTREQ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ATTREQ_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ATTREQ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTREQ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTREQ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->ATTREQ);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTDIA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ATTDIA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTDIA_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ATTDIA_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ATTDIA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTDIA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTDIA_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->ATTDIA);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MIRRTEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_MIRRTEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MIRRTEXT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_MIRRTEXT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->MIRRTEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MIRRTEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MIRRTEXT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->MIRRTEXT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_WORLDVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_WORLDVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_WORLDVIEW_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_WORLDVIEW_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->WORLDVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_WORLDVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_WORLDVIEW_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->WORLDVIEW);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_WIREFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_WIREFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_WIREFRAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_WIREFRAME_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->WIREFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_WIREFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_WIREFRAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->WIREFRAME);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TILEMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TILEMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TILEMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TILEMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->TILEMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TILEMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TILEMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->TILEMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMCHECK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PLIMCHECK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMCHECK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PLIMCHECK_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->PLIMCHECK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMCHECK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMCHECK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->PLIMCHECK);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VISRETAIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VISRETAIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VISRETAIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_VISRETAIN_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->VISRETAIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VISRETAIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VISRETAIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->VISRETAIN);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DELOBJ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DELOBJ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DELOBJ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DELOBJ_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DELOBJ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DELOBJ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DELOBJ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DELOBJ);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DISPSILH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DISPSILH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DISPSILH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DISPSILH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DISPSILH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DISPSILH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DISPSILH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DISPSILH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PELLIPSE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PELLIPSE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PELLIPSE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PELLIPSE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->PELLIPSE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PELLIPSE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PELLIPSE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->PELLIPSE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SAVEIMAGES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SAVEIMAGES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SAVEIMAGES_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SAVEIMAGES_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SAVEIMAGES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SAVEIMAGES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SAVEIMAGES_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SAVEIMAGES);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PROXYGRAPHICS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PROXYGRAPHICS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PROXYGRAPHICS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PROXYGRAPHICS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->PROXYGRAPHICS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PROXYGRAPHICS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PROXYGRAPHICS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->PROXYGRAPHICS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MEASUREMENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_MEASUREMENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MEASUREMENT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_MEASUREMENT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->MEASUREMENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MEASUREMENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MEASUREMENT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->MEASUREMENT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DRAGMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DRAGMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DRAGMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DRAGMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DRAGMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DRAGMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DRAGMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DRAGMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TREEDEPTH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TREEDEPTH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TREEDEPTH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TREEDEPTH_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->TREEDEPTH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TREEDEPTH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TREEDEPTH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->TREEDEPTH);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LUNITS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LUNITS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LUNITS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LUNITS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->LUNITS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LUNITS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LUNITS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->LUNITS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LUPREC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LUPREC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LUPREC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LUPREC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->LUPREC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LUPREC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LUPREC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->LUPREC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AUNITS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_AUNITS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AUNITS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_AUNITS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->AUNITS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AUNITS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AUNITS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->AUNITS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AUPREC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_AUPREC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AUPREC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_AUPREC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->AUPREC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AUPREC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AUPREC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->AUPREC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ATTMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ATTMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->ATTMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ATTMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ATTMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->ATTMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_COORDS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_COORDS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_COORDS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_COORDS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->COORDS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_COORDS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_COORDS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->COORDS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PDMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PDMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PDMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PDMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->PDMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PDMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PDMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->PDMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PICKSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PICKSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PICKSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PICKSTYLE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->PICKSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PICKSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PICKSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->PICKSTYLE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OSMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_OSMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OSMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_OSMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->OSMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OSMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OSMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->OSMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_12_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_12_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_12_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_12_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_12 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_12_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_12_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_12);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_13_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_13_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_13_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_13_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_13 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_13_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_13_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_13);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_14_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_14_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_14_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_14_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_14 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_14_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_14_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_14);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERI1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERI1_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->USERI1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->USERI1);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERI2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERI2_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->USERI2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->USERI2);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERI3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI3_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERI3_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->USERI3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI3_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->USERI3);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERI4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI4_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERI4_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->USERI4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI4_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->USERI4);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERI5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI5_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERI5_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->USERI5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERI5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERI5_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->USERI5);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLINESEGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SPLINESEGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLINESEGS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SPLINESEGS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SPLINESEGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLINESEGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLINESEGS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SPLINESEGS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SURFU_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFU_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SURFU_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SURFU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFU_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SURFU);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SURFV_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFV_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SURFV_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SURFV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFV_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SURFV);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SURFTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SURFTYPE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SURFTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SURFTYPE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTAB1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SURFTAB1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTAB1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SURFTAB1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SURFTAB1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTAB1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTAB1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SURFTAB1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTAB2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SURFTAB2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTAB2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SURFTAB2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SURFTAB2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SURFTAB2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SURFTAB2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SURFTAB2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLINETYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SPLINETYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLINETYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SPLINETYPE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SPLINETYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SPLINETYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SPLINETYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SPLINETYPE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADEDGE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SHADEDGE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADEDGE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SHADEDGE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SHADEDGE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADEDGE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADEDGE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SHADEDGE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADEDIF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SHADEDIF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADEDIF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SHADEDIF_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SHADEDIF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADEDIF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADEDIF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->SHADEDIF);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UNITMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UNITMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UNITMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_UNITMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UNITMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UNITMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UNITMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->UNITMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MAXACTVP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_MAXACTVP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MAXACTVP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_MAXACTVP_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->MAXACTVP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MAXACTVP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MAXACTVP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->MAXACTVP);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ISOLINES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ISOLINES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ISOLINES_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ISOLINES_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->ISOLINES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ISOLINES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ISOLINES_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->ISOLINES);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLJUST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CMLJUST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLJUST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CMLJUST_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->CMLJUST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLJUST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLJUST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->CMLJUST);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTQLTY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TEXTQLTY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTQLTY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TEXTQLTY_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->TEXTQLTY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTQLTY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTQLTY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->TEXTQLTY);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_14b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_14b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_14b_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_14b_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_14b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_14b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_14b_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_14b);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LTSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LTSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LTSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LTSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TEXTSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTSIZE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TEXTSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->TEXTSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTSIZE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->TEXTSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TRACEWID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TRACEWID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TRACEWID_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TRACEWID_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->TRACEWID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TRACEWID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TRACEWID_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->TRACEWID);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SKETCHINC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SKETCHINC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SKETCHINC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SKETCHINC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->SKETCHINC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SKETCHINC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SKETCHINC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->SKETCHINC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FILLETRAD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FILLETRAD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FILLETRAD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FILLETRAD_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->FILLETRAD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FILLETRAD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FILLETRAD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->FILLETRAD);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_THICKNESS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_THICKNESS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_THICKNESS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_THICKNESS_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->THICKNESS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_THICKNESS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_THICKNESS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->THICKNESS);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ANGBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ANGBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ANGBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ANGBASE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ANGBASE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ANGBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ANGBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->ANGBASE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PDSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PDSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PDSIZE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PDSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PDSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PDSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PDSIZE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PDSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLINEWID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PLINEWID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLINEWID_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PLINEWID_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PLINEWID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLINEWID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLINEWID_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PLINEWID);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERR1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERR1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->USERR1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->USERR1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERR2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERR2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->USERR2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->USERR2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERR3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR3_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERR3_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->USERR3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR3_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->USERR3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERR4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR4_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERR4_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->USERR4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR4_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->USERR4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_USERR5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR5_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_USERR5_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->USERR5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_USERR5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_USERR5_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->USERR5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CHAMFERA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERA_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CHAMFERA_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CHAMFERA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERA_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CHAMFERA);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERB_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CHAMFERB_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERB_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CHAMFERB_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CHAMFERB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERB_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CHAMFERB);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CHAMFERC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CHAMFERC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CHAMFERC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CHAMFERC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CHAMFERD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CHAMFERD_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CHAMFERD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CHAMFERD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CHAMFERD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CHAMFERD);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FACETRES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FACETRES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FACETRES_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FACETRES_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->FACETRES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FACETRES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FACETRES_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->FACETRES);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CMLSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CMLSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CMLSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CMLSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELTSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CELTSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELTSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CELTSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CELTSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELTSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELTSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CELTSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWTWIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEWTWIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWTWIST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_VIEWTWIST_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->VIEWTWIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWTWIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWTWIST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->VIEWTWIST);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MENU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_MENU_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MENU_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_MENU_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->MENU);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->MENU = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->MENU = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_MENU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_MENU_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->MENU);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDCREATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDCREATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDCREATE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDCREATE_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDCREATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDCREATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDCREATE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDCREATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUPDATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDUPDATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUPDATE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDUPDATE_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDUPDATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUPDATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUPDATE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDUPDATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUCREATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDUCREATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUCREATE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDUCREATE_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDUCREATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUCREATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUCREATE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDUCREATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUUPDATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDUUPDATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUUPDATE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDUUPDATE_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDUUPDATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUUPDATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUUPDATE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDUUPDATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_15_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_15_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_15_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_15_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_15 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_15_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_15_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_15);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_16_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_16_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_16_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_16_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_16 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_16_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_16_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_16);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_17_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_17_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_17_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_17_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_17 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_17_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_17_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_17);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDINDWG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDINDWG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDINDWG_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDINDWG_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDINDWG = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDINDWG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDINDWG_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDINDWG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUSRTIMER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TDUSRTIMER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUSRTIMER_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TDUSRTIMER_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->TDUSRTIMER = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TDUSRTIMER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TDUSRTIMER_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->TDUSRTIMER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CECOLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CECOLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CECOLOR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CECOLOR_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->CECOLOR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CECOLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CECOLOR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->CECOLOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HANDLING_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_HANDLING_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HANDLING_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_HANDLING_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->HANDLING = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HANDLING_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HANDLING_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->HANDLING);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HANDSEED_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_HANDSEED_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HANDSEED_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_HANDSEED_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->HANDSEED = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HANDSEED_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HANDSEED_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->HANDSEED);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_4f2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_4f2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_4f2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_4f2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_4f2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_4f2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_4f2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_4f2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_5_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_5_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_5_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_5);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_6_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_6_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_6 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_6);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_6a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6a_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_6a_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_6a = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6a_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_6a);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_6b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6b_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_6b_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_6b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6b_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_6b);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_6c_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6c_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_6c_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_6c = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_6c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_6c_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_6c);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CLAYER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CLAYER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CLAYER_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CLAYER_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->CLAYER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CLAYER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CLAYER_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->CLAYER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TEXTSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TEXTSTYLE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->TEXTSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TEXTSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TEXTSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->TEXTSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CELTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELTYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CELTYPE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->CELTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELTYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->CELTYPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMATERIAL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CMATERIAL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMATERIAL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CMATERIAL_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->CMATERIAL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMATERIAL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMATERIAL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->CMATERIAL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMSTYLE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CMLSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CMLSTYLE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->CMLSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CMLSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CMLSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->CMLSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSVPSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PSVPSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSVPSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PSVPSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PSVPSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSVPSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSVPSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PSVPSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PINSBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PINSBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PINSBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PINSBASE_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PINSBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PINSBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PINSBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PINSBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PEXTMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PEXTMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PEXTMIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PEXTMIN_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PEXTMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PEXTMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PEXTMIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PEXTMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PEXTMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PEXTMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PEXTMAX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PEXTMAX_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PEXTMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PEXTMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PEXTMAX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PEXTMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PLIMMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMMIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PLIMMIN_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->PLIMMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMMIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->PLIMMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PLIMMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMMAX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PLIMMAX_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->PLIMMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PLIMMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PLIMMAX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->PLIMMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PELEVATION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PELEVATION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PELEVATION_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PELEVATION_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PELEVATION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PELEVATION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PELEVATION_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PELEVATION);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORG_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORG_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORG = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORG_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSXDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSXDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSXDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSXDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSXDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSXDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSXDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSXDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSYDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSYDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSYDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSYDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSYDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSYDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSYDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSYDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSNAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSNAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSNAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSNAME_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->PUCSNAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSNAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSNAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->PUCSNAME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSBASE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->PUCSBASE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->PUCSBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORTHOREF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORTHOREF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORTHOREF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORTHOREF_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->PUCSORTHOREF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORTHOREF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORTHOREF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->PUCSORTHOREF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PUCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->PUCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->PUCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGTOP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGTOP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGTOP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGTOP_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGTOP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGTOP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGTOP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGTOP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGBOTTOM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGBOTTOM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGBOTTOM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGBOTTOM_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGBOTTOM = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGBOTTOM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGBOTTOM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGBOTTOM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGLEFT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGLEFT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGLEFT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGLEFT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGLEFT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGLEFT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGLEFT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGLEFT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGRIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGRIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGRIGHT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGRIGHT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGRIGHT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGRIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGRIGHT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGRIGHT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGFRONT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGFRONT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGFRONT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGFRONT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGFRONT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGFRONT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGFRONT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGFRONT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGBACK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PUCSORGBACK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGBACK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PUCSORGBACK_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->PUCSORGBACK = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PUCSORGBACK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PUCSORGBACK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->PUCSORGBACK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INSBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INSBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INSBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_INSBASE_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->INSBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INSBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INSBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->INSBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_EXTMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTMIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_EXTMIN_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->EXTMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTMIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->EXTMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_EXTMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTMAX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_EXTMAX_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->EXTMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTMAX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->EXTMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEWDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VIEWDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->VIEWDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->VIEWDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TARGET_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TARGET_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TARGET_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_TARGET_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->TARGET = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TARGET_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TARGET_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->TARGET);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LIMMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMMIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LIMMIN_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->LIMMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMMIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->LIMMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LIMMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMMAX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LIMMAX_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->LIMMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIMMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIMMAX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->LIMMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWCTR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEWCTR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWCTR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VIEWCTR_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VIEWCTR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWCTR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWCTR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VIEWCTR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ELEVATION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ELEVATION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ELEVATION_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ELEVATION_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ELEVATION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ELEVATION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ELEVATION_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->ELEVATION);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEWSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWSIZE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_VIEWSIZE_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->VIEWSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEWSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEWSIZE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RD) ((arg1)->VIEWSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SNAPMODE_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->SNAPMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->SNAPMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_SNAPUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_SNAPBASE_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPANG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPANG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPANG_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SNAPANG_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->SNAPANG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPANG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPANG_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RD) ((arg1)->SNAPANG);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SNAPSTYLE_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->SNAPSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->SNAPSTYLE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPISOPAIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SNAPISOPAIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPISOPAIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SNAPISOPAIR_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->SNAPISOPAIR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SNAPISOPAIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SNAPISOPAIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->SNAPISOPAIR);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_GRIDMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_GRIDMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_GRIDMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_GRIDMODE_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->GRIDMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_GRIDMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_GRIDMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->GRIDMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_GRIDUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_GRIDUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_GRIDUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_GRIDUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->GRIDUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_GRIDUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_GRIDUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->GRIDUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AXISMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_AXISMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AXISMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_AXISMODE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->AXISMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AXISMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AXISMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->AXISMODE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AXISUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_AXISUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AXISUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_AXISUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->AXISUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_AXISUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_AXISUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->AXISUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTX_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTY_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTY = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTZ_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTZ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTXALT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTXALT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTXALT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTXALT_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTXALT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTXALT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTXALT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTXALT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTYALT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTYALT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTYALT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTYALT_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTYALT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTYALT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTYALT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTYALT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTZALT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPOINTZALT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTZALT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPOINTZALT_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->VPOINTZALT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPOINTZALT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPOINTZALT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->VPOINTZALT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_flag_3d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_flag_3d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_flag_3d_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_flag_3d_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flag_3d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_flag_3d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_flag_3d_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->flag_3d);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORG_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORG_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORG = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORG_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSXDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSXDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSXDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSXDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSXDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSXDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSXDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSXDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSYDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSYDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSYDIR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSYDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSYDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSYDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSYDIR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSYDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSNAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSNAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSNAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSNAME_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->UCSNAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSNAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSNAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->UCSNAME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSBASE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->UCSBASE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->UCSBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORTHOREF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORTHOREF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORTHOREF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORTHOREF_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->UCSORTHOREF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORTHOREF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORTHOREF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->UCSORTHOREF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGTOP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGTOP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGTOP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGTOP_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGTOP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGTOP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGTOP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGTOP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGBOTTOM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGBOTTOM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGBOTTOM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGBOTTOM_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGBOTTOM = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGBOTTOM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGBOTTOM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGBOTTOM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGLEFT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGLEFT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGLEFT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGLEFT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGLEFT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGLEFT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGLEFT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGLEFT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGRIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGRIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGRIGHT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGRIGHT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGRIGHT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGRIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGRIGHT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGRIGHT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGFRONT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGFRONT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGFRONT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGFRONT_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGFRONT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGFRONT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGFRONT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGFRONT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGBACK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSORGBACK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGBACK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCSORGBACK_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->UCSORGBACK = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSORGBACK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSORGBACK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->UCSORGBACK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMPOST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMPOST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMPOST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMPOST_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMPOST);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMPOST = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMPOST = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMPOST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMPOST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMPOST);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAPOST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMAPOST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAPOST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMAPOST_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMAPOST);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMAPOST = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMAPOST = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAPOST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAPOST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMAPOST);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTOL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTOL_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOL);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLIM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLIM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLIM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMLIM_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMLIM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLIM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLIM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMLIM);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTIH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTIH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTIH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTIH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTIH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTIH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTIH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTIH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTOH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTOH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSE1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSE1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSE1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSE1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSE1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSE1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSE1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSE1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSE2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSE2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSE2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSE2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSE2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSE2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSE2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSE2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMALT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMALT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOFL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTOFL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOFL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTOFL_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOFL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOFL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOFL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOFL);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSAH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSAH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSAH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSAH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSAH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSAH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSAH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSAH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTIX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTIX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTIX_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTIX_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTIX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTIX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTIX_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTIX);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSOXD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSOXD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSOXD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSOXD_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSOXD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSOXD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSOXD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSOXD);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMZIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMZIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSD1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSD1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSD1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSD1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSD1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSD1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSD1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSD1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSD2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSD2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSD2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSD2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSD2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSD2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSD2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSD2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOLJ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTOLJ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOLJ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTOLJ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTOLJ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTOLJ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTOLJ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTOLJ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMJUST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMJUST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMJUST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMJUST_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMJUST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMJUST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMJUST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMJUST);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMFIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMFIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMFIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMFIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMUPT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMUPT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMUPT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMUPT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMUPT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMUPT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMUPT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMUPT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTZIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTZIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTAD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTAD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTAD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTAD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTAD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTAD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTAD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTAD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMAUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMAUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMAUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMAUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMDEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDEC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMDEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMDEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDEC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMDEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTDEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTDEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTDEC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTDEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTDEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTDEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTDEC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTDEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTU_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTU_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTU_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTU_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTU);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTTD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTTD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTTD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTTD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTTD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTTD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTTD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTTD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXSTY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTXSTY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXSTY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMTXSTY_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMTXSTY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXSTY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXSTY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMTXSTY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMARROW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMARROW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMARROW_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMARROW_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMARROW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMARROW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMARROW_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMARROW);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMASZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMASZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMASZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMASZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMEXO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMEXO_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMEXO_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMEXO_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMEXO = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMEXO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMEXO_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMEXO);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDLI_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMDLI_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDLI_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMDLI_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMDLI = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDLI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDLI_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMDLI);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMEXE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMEXE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMEXE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMEXE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMEXE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMEXE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMEXE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMEXE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMRND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMRND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMRND_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMRND_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMRND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMRND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMRND_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMRND);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMDLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMDLE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMDLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMDLE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTM_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTM);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFXL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMFXL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFXL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMFXL_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMFXL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFXL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFXL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMFXL);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMJOGANG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMJOGANG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMJOGANG_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMJOGANG_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMJOGANG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMJOGANG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMJOGANG_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMJOGANG);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFILL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTFILL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFILL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTFILL_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTFILL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFILL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFILL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTFILL);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFILLCLR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTFILLCLR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFILLCLR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMTFILLCLR_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMTFILLCLR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFILLCLR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFILLCLR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMTFILLCLR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMAZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAZIN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMAZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMAZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAZIN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMAZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMARCSYM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMARCSYM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMARCSYM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMARCSYM_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMARCSYM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMARCSYM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMARCSYM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMARCSYM);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTXT_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTXT);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCEN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCEN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCEN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMCEN_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMCEN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCEN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCEN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMCEN);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTSZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTSZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTSZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTSZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTSZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTSZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTSZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTSZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLFAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLFAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLFAC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMLFAC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMLFAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLFAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLFAC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMLFAC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTVP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTVP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTVP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTVP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTVP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTVP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTVP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTVP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTFAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFAC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTFAC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTFAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTFAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTFAC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTFAC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMGAP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMGAP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMGAP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMGAP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMGAP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMGAP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMGAP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMGAP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMPOST_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMPOST_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMPOST_T_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMPOST_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMPOST_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMPOST_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMPOST_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMPOST_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMPOST_T_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMPOST_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAPOST_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMAPOST_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAPOST_T_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMAPOST_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMAPOST_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMAPOST_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMAPOST_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMAPOST_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMAPOST_T_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMAPOST_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK_T_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK_T_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK1_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK1_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK1_T_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK1_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK1_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK1_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK1_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK1_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK1_T_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK1_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK2_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK2_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK2_T_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK2_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK2_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK2_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK2_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK2_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK2_T_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK2_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_string_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unknown_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unknown_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unknown_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unknown_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_string_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->unknown_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTRND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTRND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTRND_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTRND_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTRND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTRND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTRND_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTRND);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRD_C_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRD_C_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRD_C_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMCLRD_C_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRD_C = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRD_C_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRD_C_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRD_C);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRE_C_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRE_C_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRE_C_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMCLRE_C_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRE_C = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRE_C_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRE_C_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRE_C);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRT_C_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRT_C_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRT_C_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMCLRT_C_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRT_C = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRT_C_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRT_C_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRT_C);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMCLRD_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRD = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMCLRE_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMCLRT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMCLRT_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMCLRT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMCLRT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMADEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMADEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMADEC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMADEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMADEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMADEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMADEC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMADEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFRAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMFRAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFRAC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMFRAC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMFRAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFRAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFRAC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMFRAC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLUNIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMLUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMLUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLUNIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMLUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDSEP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMDSEP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDSEP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMDSEP_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMDSEP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMDSEP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMDSEP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMDSEP);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTMOVE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTMOVE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTMOVE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTMOVE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTMOVE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTMOVE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTMOVE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTMOVE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTZ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTZ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTTZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTTZ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTTZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTTZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTTZ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMATFIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMATFIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMATFIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMATFIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMATFIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMATFIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMATFIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMATFIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFXLON_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMFXLON_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFXLON_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMFXLON_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMFXLON = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMFXLON_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMFXLON_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMFXLON);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXTDIRECTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMTXTDIRECTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXTDIRECTION_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMTXTDIRECTION_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTXTDIRECTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMTXTDIRECTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMTXTDIRECTION_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTXTDIRECTION);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTMZF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTMZF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTMZF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMALTMZF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTMZF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTMZF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTMZF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTMZF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTMZS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMALTMZS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTMZS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMALTMZS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMALTMZS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMALTMZS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMALTMZS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMALTMZS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMALTMZS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMALTMZS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMMZF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMMZF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMMZF_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMMZF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMMZF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMMZF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMMZF_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMMZF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMMZS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMMZS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMMZS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMMZS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMMZS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMMZS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMMZS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMMZS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMMZS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMMZS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLDRBLK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLDRBLK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLDRBLK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMLDRBLK_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLDRBLK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLDRBLK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLDRBLK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLDRBLK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMBLK2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMBLK2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMBLK2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMBLK2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMLTYPE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTYPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTEX1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLTEX1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTEX1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMLTEX1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTEX1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTEX1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTEX1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTEX1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTEX2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLTEX2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTEX2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMLTEX2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTEX2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLTEX2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLTEX2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTEX2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLWD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLWD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLWD_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMLWD_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->DIMLWD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLWD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLWD_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->DIMLWD);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLWE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMLWE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLWE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMLWE_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->DIMLWE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMLWE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMLWE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->DIMLWE);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->BLOCK_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->BLOCK_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->LAYER_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LAYER_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->LAYER_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->STYLE_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STYLE_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->STYLE_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->LTYPE_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->LTYPE_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->VIEW_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VIEW_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->VIEW_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCS_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCS_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCS_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_UCS_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->UCS_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCS_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCS_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->UCS_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->VPORT_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VPORT_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->VPORT_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_APPID_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_APPID_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_APPID_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_APPID_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->APPID_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_APPID_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_APPID_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->APPID_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMSTYLE_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMSTYLE_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VX_CONTROL_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VX_CONTROL_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VX_CONTROL_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VX_CONTROL_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->VX_CONTROL_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VX_CONTROL_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VX_CONTROL_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->VX_CONTROL_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_ACAD_GROUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_ACAD_GROUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_ACAD_MLINESTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_ACAD_MLINESTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_NAMED_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_NAMED_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TSTACKALIGN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TSTACKALIGN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TSTACKALIGN_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TSTACKALIGN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->TSTACKALIGN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TSTACKALIGN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TSTACKALIGN_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->TSTACKALIGN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TSTACKSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TSTACKSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TSTACKSIZE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TSTACKSIZE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->TSTACKSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TSTACKSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TSTACKSIZE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->TSTACKSIZE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HYPERLINKBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_HYPERLINKBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HYPERLINKBASE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_HYPERLINKBASE_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->HYPERLINKBASE);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->HYPERLINKBASE = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->HYPERLINKBASE = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HYPERLINKBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HYPERLINKBASE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->HYPERLINKBASE);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STYLESHEET_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_STYLESHEET_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STYLESHEET_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_STYLESHEET_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->STYLESHEET);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->STYLESHEET = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->STYLESHEET = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STYLESHEET_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STYLESHEET_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->STYLESHEET);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_LAYOUT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_LAYOUT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_LAYOUT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_LAYOUT_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_LAYOUT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_LAYOUT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_LAYOUT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_LAYOUT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_PLOTSETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_PLOTSETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_PLOTSTYLENAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_PLOTSTYLENAME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_MATERIAL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_MATERIAL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_MATERIAL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_MATERIAL_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_MATERIAL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_MATERIAL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_MATERIAL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_MATERIAL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_COLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_COLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_COLOR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_COLOR_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_COLOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_COLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_COLOR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_COLOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_VISUALSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_VISUALSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DICTIONARY_LIGHTLIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DICTIONARY_LIGHTLIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DICTIONARY_LIGHTLIST);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_20_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_20_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_20_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_unknown_20_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->unknown_20 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_20_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_20_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->unknown_20);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FLAGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FLAGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FLAGS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FLAGS_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->FLAGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FLAGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FLAGS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->FLAGS);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELWEIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CELWEIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELWEIGHT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CELWEIGHT_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->CELWEIGHT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CELWEIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CELWEIGHT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BSd) ((arg1)->CELWEIGHT);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ENDCAPS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_ENDCAPS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ENDCAPS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_ENDCAPS_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ENDCAPS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_ENDCAPS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_ENDCAPS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->ENDCAPS);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_JOINSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_JOINSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_JOINSTYLE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_JOINSTYLE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->JOINSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_JOINSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_JOINSTYLE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->JOINSTYLE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LWDISPLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LWDISPLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LWDISPLAY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LWDISPLAY_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->LWDISPLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LWDISPLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LWDISPLAY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->LWDISPLAY);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_XEDIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_XEDIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_XEDIT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_XEDIT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->XEDIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_XEDIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_XEDIT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->XEDIT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTNAMES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_EXTNAMES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTNAMES_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_EXTNAMES_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->EXTNAMES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_EXTNAMES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_EXTNAMES_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->EXTNAMES);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSTYLEMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PSTYLEMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSTYLEMODE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PSTYLEMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->PSTYLEMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSTYLEMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSTYLEMODE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->PSTYLEMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OLESTARTUP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_OLESTARTUP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OLESTARTUP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_OLESTARTUP_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->OLESTARTUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OLESTARTUP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OLESTARTUP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->OLESTARTUP);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INSUNITS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INSUNITS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INSUNITS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_INSUNITS_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->INSUNITS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INSUNITS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INSUNITS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->INSUNITS);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CEPSNTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CEPSNTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CEPSNTYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CEPSNTYPE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->CEPSNTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CEPSNTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CEPSNTYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->CEPSNTYPE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CPSNID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CPSNID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CPSNID_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_CPSNID_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->CPSNID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CPSNID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CPSNID_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->CPSNID);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FINGERPRINTGUID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FINGERPRINTGUID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FINGERPRINTGUID_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_FINGERPRINTGUID_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->FINGERPRINTGUID);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->FINGERPRINTGUID = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->FINGERPRINTGUID = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FINGERPRINTGUID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FINGERPRINTGUID_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->FINGERPRINTGUID);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VERSIONGUID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_VERSIONGUID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VERSIONGUID_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_VERSIONGUID_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->VERSIONGUID);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->VERSIONGUID = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->VERSIONGUID = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_VERSIONGUID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_VERSIONGUID_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->VERSIONGUID);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SORTENTS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SORTENTS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SORTENTS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SORTENTS_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->SORTENTS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SORTENTS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SORTENTS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->SORTENTS);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INDEXCTL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INDEXCTL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INDEXCTL_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_INDEXCTL_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->INDEXCTL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INDEXCTL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INDEXCTL_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->INDEXCTL);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HIDETEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_HIDETEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HIDETEXT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_HIDETEXT_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->HIDETEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HIDETEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HIDETEXT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->HIDETEXT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_XCLIPFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_XCLIPFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_XCLIPFRAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_XCLIPFRAME_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->XCLIPFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_XCLIPFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_XCLIPFRAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->XCLIPFRAME);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASSOC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DIMASSOC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASSOC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DIMASSOC_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->DIMASSOC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DIMASSOC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DIMASSOC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->DIMASSOC);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HALOGAP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_HALOGAP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HALOGAP_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_HALOGAP_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->HALOGAP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_HALOGAP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_HALOGAP_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->HALOGAP);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OBSCOLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_OBSCOLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OBSCOLOR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_OBSCOLOR_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->OBSCOLOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OBSCOLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OBSCOLOR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->OBSCOLOR);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERSECTIONCOLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INTERSECTIONCOLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERSECTIONCOLOR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_INTERSECTIONCOLOR_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->INTERSECTIONCOLOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERSECTIONCOLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERSECTIONCOLOR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->INTERSECTIONCOLOR);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OBSLTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_OBSLTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OBSLTYPE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_OBSLTYPE_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->OBSLTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_OBSLTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_OBSLTYPE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->OBSLTYPE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERSECTIONDISPLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INTERSECTIONDISPLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERSECTIONDISPLAY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_INTERSECTIONDISPLAY_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->INTERSECTIONDISPLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERSECTIONDISPLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERSECTIONDISPLAY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->INTERSECTIONDISPLAY);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PROJECTNAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PROJECTNAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PROJECTNAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_PROJECTNAME_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->PROJECTNAME);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->PROJECTNAME = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->PROJECTNAME = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PROJECTNAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PROJECTNAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_TV) ((arg1)->PROJECTNAME);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->BLOCK_RECORD_PSPACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_RECORD_PSPACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->BLOCK_RECORD_PSPACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->BLOCK_RECORD_MSPACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BLOCK_RECORD_MSPACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->BLOCK_RECORD_MSPACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_BYLAYER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LTYPE_BYLAYER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_BYLAYER_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LTYPE_BYLAYER_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->LTYPE_BYLAYER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_BYLAYER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_BYLAYER_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->LTYPE_BYLAYER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_BYBLOCK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LTYPE_BYBLOCK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_BYBLOCK_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LTYPE_BYBLOCK_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->LTYPE_BYBLOCK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_BYBLOCK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_BYBLOCK_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->LTYPE_BYBLOCK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_CONTINUOUS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LTYPE_CONTINUOUS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_CONTINUOUS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_LTYPE_CONTINUOUS_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->LTYPE_CONTINUOUS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LTYPE_CONTINUOUS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LTYPE_CONTINUOUS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->LTYPE_CONTINUOUS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CAMERADISPLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CAMERADISPLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CAMERADISPLAY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CAMERADISPLAY_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->CAMERADISPLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CAMERADISPLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CAMERADISPLAY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->CAMERADISPLAY);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_21_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_21_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_21_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_21_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_21 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_21_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_21_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_21);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_22_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_22_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_22_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_22_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_22 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_22_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_22_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_22);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_23_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_23_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_23_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_23_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unknown_23 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_23_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_23_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->unknown_23);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STEPSPERSEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_STEPSPERSEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STEPSPERSEC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_STEPSPERSEC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->STEPSPERSEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STEPSPERSEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STEPSPERSEC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->STEPSPERSEC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STEPSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_STEPSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STEPSIZE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_STEPSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->STEPSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_STEPSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_STEPSIZE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->STEPSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables__3DDWFPREC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables__3DDWFPREC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables__3DDWFPREC_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables__3DDWFPREC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->_3DDWFPREC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables__3DDWFPREC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables__3DDWFPREC_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->_3DDWFPREC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LENSLENGTH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LENSLENGTH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LENSLENGTH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LENSLENGTH_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LENSLENGTH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LENSLENGTH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LENSLENGTH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LENSLENGTH);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CAMERAHEIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CAMERAHEIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CAMERAHEIGHT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CAMERAHEIGHT_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->CAMERAHEIGHT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CAMERAHEIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CAMERAHEIGHT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->CAMERAHEIGHT);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SOLIDHIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SOLIDHIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SOLIDHIST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SOLIDHIST_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->SOLIDHIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SOLIDHIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SOLIDHIST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->SOLIDHIST);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHOWHIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SHOWHIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHOWHIST_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SHOWHIST_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->SHOWHIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHOWHIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHOWHIST_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->SHOWHIST);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSOLWIDTH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PSOLWIDTH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSOLWIDTH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PSOLWIDTH_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PSOLWIDTH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSOLWIDTH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSOLWIDTH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PSOLWIDTH);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSOLHEIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_PSOLHEIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSOLHEIGHT_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_PSOLHEIGHT_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->PSOLHEIGHT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_PSOLHEIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_PSOLHEIGHT_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->PSOLHEIGHT);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTANG1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTANG1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTANG1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTANG1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LOFTANG1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTANG1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTANG1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LOFTANG1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTANG2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTANG2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTANG2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTANG2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LOFTANG2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTANG2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTANG2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LOFTANG2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTMAG1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTMAG1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTMAG1_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTMAG1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LOFTMAG1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTMAG1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTMAG1_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LOFTMAG1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTMAG2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTMAG2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTMAG2_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTMAG2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LOFTMAG2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTMAG2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTMAG2_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LOFTMAG2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTPARAM_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTPARAM_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->LOFTPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTPARAM_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->LOFTPARAM);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTNORMALS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LOFTNORMALS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTNORMALS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LOFTNORMALS_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->LOFTNORMALS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LOFTNORMALS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LOFTNORMALS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->LOFTNORMALS);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LATITUDE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LATITUDE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LATITUDE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LATITUDE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LATITUDE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LATITUDE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LATITUDE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LATITUDE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LONGITUDE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LONGITUDE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LONGITUDE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LONGITUDE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->LONGITUDE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LONGITUDE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LONGITUDE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->LONGITUDE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_NORTHDIRECTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_NORTHDIRECTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_NORTHDIRECTION_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_NORTHDIRECTION_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->NORTHDIRECTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_NORTHDIRECTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_NORTHDIRECTION_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->NORTHDIRECTION);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TIMEZONE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TIMEZONE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TIMEZONE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TIMEZONE_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->TIMEZONE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TIMEZONE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TIMEZONE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BL) ((arg1)->TIMEZONE);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->LIGHTGLYPHDISPLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_LIGHTGLYPHDISPLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->LIGHTGLYPHDISPLAY);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TILEMODELIGHTSYNCH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_TILEMODELIGHTSYNCH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TILEMODELIGHTSYNCH_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_TILEMODELIGHTSYNCH_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->TILEMODELIGHTSYNCH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_TILEMODELIGHTSYNCH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_TILEMODELIGHTSYNCH_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->TILEMODELIGHTSYNCH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DWFFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DWFFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DWFFRAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DWFFRAME_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->DWFFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DWFFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DWFFRAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->DWFFRAME);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DGNFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DGNFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DGNFRAME_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_DGNFRAME_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->DGNFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DGNFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DGNFRAME_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->DGNFRAME);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REALWORLDSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_REALWORLDSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REALWORLDSCALE_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_REALWORLDSCALE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->REALWORLDSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_REALWORLDSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_REALWORLDSCALE_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_B) ((arg1)->REALWORLDSCALE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFERECOLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INTERFERECOLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFERECOLOR_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_INTERFERECOLOR_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->INTERFERECOLOR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFERECOLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFERECOLOR_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->INTERFERECOLOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFEREOBJVS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INTERFEREOBJVS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFEREOBJVS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_INTERFEREOBJVS_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->INTERFEREOBJVS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFEREOBJVS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFEREOBJVS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->INTERFEREOBJVS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFEREVPVS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_INTERFEREVPVS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFEREVPVS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_INTERFEREVPVS_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->INTERFEREVPVS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_INTERFEREVPVS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_INTERFEREVPVS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->INTERFEREVPVS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DRAGVS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_DRAGVS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DRAGVS_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_DRAGVS_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DRAGVS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_DRAGVS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_DRAGVS_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_H) ((arg1)->DRAGVS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CSHADOW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_CSHADOW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CSHADOW_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_CSHADOW_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->CSHADOW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_CSHADOW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_CSHADOW_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->CSHADOW);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADOWPLANELOCATION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_SHADOWPLANELOCATION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADOWPLANELOCATION_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_SHADOWPLANELOCATION_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->SHADOWPLANELOCATION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_SHADOWPLANELOCATION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_SHADOWPLANELOCATION_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->SHADOWPLANELOCATION);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_54_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_54_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_54_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_54_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_54 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_54_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_54_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_54);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_55_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_55_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_55_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_55_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_55 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_55_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_55_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_55);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_56_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_56_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_56_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_56_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_56 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_56_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_56_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_56);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_57_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_57_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_57_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_57_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_57 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_57_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_57_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_57);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_dwg_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_dwg_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_dwg_size_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_dwg_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->dwg_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_dwg_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_dwg_size_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->dwg_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_numentities_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_numentities_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_numentities_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_numentities_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numentities = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_numentities_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_numentities_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->numentities);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_circle_zoom_percent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_circle_zoom_percent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_circle_zoom_percent_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_circle_zoom_percent_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->circle_zoom_percent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_circle_zoom_percent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_circle_zoom_percent_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->circle_zoom_percent);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FRONTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_FRONTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FRONTZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_FRONTZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->FRONTZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_FRONTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_FRONTZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->FRONTZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BACKZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_BACKZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BACKZ_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_BACKZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->BACKZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_BACKZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_BACKZ_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_BD) ((arg1)->BACKZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSICON_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_UCSICON_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSICON_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_UCSICON_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->UCSICON = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_UCSICON_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_UCSICON_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->UCSICON);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_oldCECOLOR_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_oldCECOLOR_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_oldCECOLOR_hi_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_oldCECOLOR_hi_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->oldCECOLOR_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_oldCECOLOR_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_oldCECOLOR_hi_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->oldCECOLOR_hi);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_oldCECOLOR_lo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_oldCECOLOR_lo_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_oldCECOLOR_lo_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_oldCECOLOR_lo_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->oldCECOLOR_lo = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_oldCECOLOR_lo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_oldCECOLOR_lo_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RL) ((arg1)->oldCECOLOR_lo);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_layer_colors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS *arg2 = (BITCODE_RS *) (BITCODE_RS *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_layer_colors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_layer_colors_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_Variables_layer_colors_set" "', argument " "2"" of type '" "BITCODE_RS [128]""'"); 
  } 
  arg2 = (BITCODE_RS *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)128; ++ii) *(BITCODE_RS *)&arg1->layer_colors[ii] = *((BITCODE_RS *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""layer_colors""' of type '""BITCODE_RS [128]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_layer_colors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_layer_colors_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS *)(BITCODE_RS *) ((arg1)->layer_colors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_51e_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_51e_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_51e_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_51e_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_51e = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_51e_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_51e_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_51e);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_520_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_520_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_520_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_520_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_520 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_520_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_520_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_520);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_52c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_52c_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_52c_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_52c_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->unknown_52c = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_52c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_52c_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RSd) ((arg1)->unknown_52c);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_52e_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_52e_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_52e_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_52e_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_52e = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_52e_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_52e_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_52e);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_530_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_530_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_530_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_530_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_530 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_530_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_530_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_530);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_59_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_unknown_59_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_59_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_unknown_59_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->unknown_59 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_unknown_59_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_unknown_59_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RS) ((arg1)->unknown_59);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_aspect_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_Variables_aspect_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_aspect_ratio_set" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_Variables_aspect_ratio_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->aspect_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_Variables_aspect_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_Variables_aspect_ratio_get" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  result = (BITCODE_RD) ((arg1)->aspect_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Header_Variables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Header_Variables", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_header_variables *)calloc(1, sizeof(struct _dwg_header_variables));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_header_variables, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Header_Variables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header_variables *arg1 = (struct _dwg_header_variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header_variables, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Header_Variables" "', argument " "1"" of type '" "struct _dwg_header_variables *""'"); 
  }
  arg1 = (struct _dwg_header_variables *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Header_Variables_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_header_variables, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Header_Variables_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_dataflags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_dataflags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_dataflags_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_dataflags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->dataflags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_dataflags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_dataflags_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RC) ((arg1)->dataflags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_elevation_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_thickness_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_rotation_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_height_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_height_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_height_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_width_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_width_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_width_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_width_factor_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->width_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_width_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_width_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_RD) ((arg1)->width_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_text_value_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_text_value_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_generation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_generation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_generation_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_generation_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->generation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_generation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_generation_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->generation);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_horiz_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_horiz_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_horiz_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_horiz_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->horiz_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_horiz_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_horiz_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->horiz_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_vert_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_vert_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_vert_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TEXT_vert_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->vert_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_vert_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_vert_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->vert_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TEXT_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_style_set" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TEXT_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TEXT_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TEXT_style_get" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_TEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_TEXT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_TEXT *)calloc(1, sizeof(struct _dwg_entity_TEXT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TEXT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_TEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TEXT *arg1 = (struct _dwg_entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_TEXT" "', argument " "1"" of type '" "struct _dwg_entity_TEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_TEXT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_TEXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_TEXT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_TEXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_attachment_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_attachment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_attachment_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BL) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDbMTextObjectEmbedded_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->x_axis_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_x_axis_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->x_axis_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_rect_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_rect_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_height_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_rect_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_height_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_rect_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_rect_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_width_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_rect_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_rect_width_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_extents_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_extents_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_width_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_extents_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_width_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_extents_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_extents_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_height_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_extents_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_extents_height_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_column_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_type_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->column_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_type_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BL) ((arg1)->column_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_column_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_width_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->column_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_width_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->column_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_gutter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_gutter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_gutter_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_gutter_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gutter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_gutter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_gutter_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD) ((arg1)->gutter);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_auto_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_auto_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_auto_height_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_auto_height_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->auto_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_auto_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_auto_height_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_B) ((arg1)->auto_height);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_flow_reversed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_flow_reversed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_flow_reversed_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_flow_reversed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flow_reversed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_flow_reversed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_flow_reversed_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_B) ((arg1)->flow_reversed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_num_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_num_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_num_column_heights_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDbMTextObjectEmbedded_num_column_heights_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_num_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_num_column_heights_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_column_heights);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDbMTextObjectEmbedded_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_heights_set" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_heights_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDbMTextObjectEmbedded_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDbMTextObjectEmbedded_column_heights_get" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  result = (BITCODE_BD *) ((arg1)->column_heights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDbMTextObjectEmbedded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDbMTextObjectEmbedded", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDbMTextObjectEmbedded *)calloc(1, sizeof(struct _dwg_AcDbMTextObjectEmbedded));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDbMTextObjectEmbedded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDbMTextObjectEmbedded *arg1 = (struct _dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDbMTextObjectEmbedded" "', argument " "1"" of type '" "struct _dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg1 = (struct _dwg_AcDbMTextObjectEmbedded *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDbMTextObjectEmbedded_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDbMTextObjectEmbedded_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_thickness_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_rotation_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_height_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_height_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_height_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_width_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_width_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_width_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_width_factor_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->width_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_width_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_width_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RD) ((arg1)->width_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_text_value_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_text_value_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_generation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_generation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_generation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_generation_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->generation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_generation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_generation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->generation);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_horiz_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_horiz_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_horiz_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_horiz_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->horiz_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_horiz_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_horiz_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->horiz_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_vert_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_vert_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_vert_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_vert_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->vert_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_vert_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_vert_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->vert_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_dataflags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_dataflags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_dataflags_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_dataflags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->dataflags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_dataflags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_dataflags_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC) ((arg1)->dataflags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_is_locked_in_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_is_locked_in_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_is_locked_in_block_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_is_locked_in_block_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_locked_in_block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_is_locked_in_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_is_locked_in_block_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_locked_in_block);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_keep_duplicate_records_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_keep_duplicate_records_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_keep_duplicate_records_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_keep_duplicate_records_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->keep_duplicate_records = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_keep_duplicate_records_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_keep_duplicate_records_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC) ((arg1)->keep_duplicate_records);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_tag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_tag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_TV) ((arg1)->tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_field_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_field_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_field_length_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_field_length_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->field_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_field_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_field_length_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->field_length);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_flags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_lock_position_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_lock_position_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_lock_position_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_lock_position_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->lock_position_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_lock_position_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_lock_position_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_B) ((arg1)->lock_position_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_mtext_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_mtext_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_mtext_type_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_mtext_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->mtext_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_mtext_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_mtext_type_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC) ((arg1)->mtext_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_mtext_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  Dwg_AcDbMTextObjectEmbedded *arg2 = (Dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_mtext_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_mtext_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_mtext_set" "', argument " "2"" of type '" "Dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg2 = (Dwg_AcDbMTextObjectEmbedded *)(argp2);
  if (arg1) (arg1)->mtext = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_mtext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDbMTextObjectEmbedded *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_mtext_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (Dwg_AcDbMTextObjectEmbedded *)& ((arg1)->mtext);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_is_really_locked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_is_really_locked_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_is_really_locked_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_is_really_locked_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_really_locked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_is_really_locked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_is_really_locked_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_B) ((arg1)->is_really_locked);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_annotative_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_annotative_data_size_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_data_size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_annotative_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_data_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_annotative_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->annotative_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_data_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_RC *) ((arg1)->annotative_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_annotative_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTRIB_annotative_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTRIB_annotative_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTRIB_annotative_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->annotative_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTRIB_annotative_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTRIB_annotative_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  result = (BITCODE_H) ((arg1)->annotative_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ATTRIB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ATTRIB", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ATTRIB *)calloc(1, sizeof(struct _dwg_entity_ATTRIB));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTRIB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ATTRIB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTRIB *arg1 = (struct _dwg_entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTRIB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ATTRIB" "', argument " "1"" of type '" "struct _dwg_entity_ATTRIB *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTRIB *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ATTRIB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ATTRIB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ATTRIB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_thickness_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_rotation_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_height_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_height_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_height_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_width_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_width_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_width_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_width_factor_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->width_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_width_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_width_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RD) ((arg1)->width_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_default_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_default_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_default_value_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_default_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->default_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->default_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->default_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_default_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_default_value_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->default_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_generation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_generation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_generation_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_generation_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->generation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_generation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_generation_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->generation);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_horiz_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_horiz_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_horiz_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_horiz_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->horiz_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_horiz_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_horiz_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->horiz_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_vert_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_vert_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_vert_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_vert_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->vert_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_vert_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_vert_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->vert_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_dataflags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_dataflags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_dataflags_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_dataflags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->dataflags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_dataflags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_dataflags_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->dataflags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_is_locked_in_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_is_locked_in_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_is_locked_in_block_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_is_locked_in_block_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_locked_in_block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_is_locked_in_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_is_locked_in_block_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_locked_in_block);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_keep_duplicate_records_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_keep_duplicate_records_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_keep_duplicate_records_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_keep_duplicate_records_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->keep_duplicate_records = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_keep_duplicate_records_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_keep_duplicate_records_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->keep_duplicate_records);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_tag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_tag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_field_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_field_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_field_length_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_field_length_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->field_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_field_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_field_length_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->field_length);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_flags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_lock_position_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_lock_position_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_lock_position_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_lock_position_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->lock_position_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_lock_position_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_lock_position_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->lock_position_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_mtext_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_mtext_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_mtext_type_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_mtext_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->mtext_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_mtext_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_mtext_type_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->mtext_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_mtext_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  Dwg_AcDbMTextObjectEmbedded *arg2 = (Dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_mtext_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_mtext_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_mtext_set" "', argument " "2"" of type '" "Dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg2 = (Dwg_AcDbMTextObjectEmbedded *)(argp2);
  if (arg1) (arg1)->mtext = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_mtext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDbMTextObjectEmbedded *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_mtext_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (Dwg_AcDbMTextObjectEmbedded *)& ((arg1)->mtext);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_is_really_locked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_is_really_locked_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_is_really_locked_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_is_really_locked_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_really_locked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_is_really_locked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_is_really_locked_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->is_really_locked);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_annotative_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_annotative_data_size_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_data_size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_annotative_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_data_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_annotative_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->annotative_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_data_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_RC *) ((arg1)->annotative_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_annotative_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ATTDEF_annotative_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_annotative_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_annotative_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->annotative_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_annotative_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_annotative_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_H) ((arg1)->annotative_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_prompt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ATTDEF_prompt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_prompt_set" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ATTDEF_prompt_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->prompt);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->prompt = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->prompt = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ATTDEF_prompt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ATTDEF_prompt_get" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->prompt);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ATTDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ATTDEF", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ATTDEF *)calloc(1, sizeof(struct _dwg_entity_ATTDEF));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTDEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ATTDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ATTDEF *arg1 = (struct _dwg_entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ATTDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ATTDEF" "', argument " "1"" of type '" "struct _dwg_entity_ATTDEF *""'"); 
  }
  arg1 = (struct _dwg_entity_ATTDEF *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ATTDEF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ATTDEF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ATTDEF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_BLOCK_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_BLOCK_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_BLOCK_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_name_set" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_BLOCK_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_name_get" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_xref_pname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_BLOCK_xref_pname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_xref_pname_set" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_BLOCK_xref_pname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->xref_pname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->xref_pname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->xref_pname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_xref_pname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_xref_pname_get" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  result = (BITCODE_TV) ((arg1)->xref_pname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_BLOCK_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_base_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_BLOCK_base_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BLOCK_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BLOCK_base_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_BLOCK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_BLOCK", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_BLOCK *)calloc(1, sizeof(struct _dwg_entity_BLOCK));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_BLOCK, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_BLOCK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BLOCK *arg1 = (struct _dwg_entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BLOCK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_BLOCK" "', argument " "1"" of type '" "struct _dwg_entity_BLOCK *""'"); 
  }
  arg1 = (struct _dwg_entity_BLOCK *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_BLOCK_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_BLOCK, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_BLOCK_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDBLK_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDBLK *arg1 = (struct _dwg_entity_ENDBLK *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDBLK_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDBLK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDBLK_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDBLK *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDBLK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ENDBLK_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDBLK_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDBLK *arg1 = (struct _dwg_entity_ENDBLK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDBLK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDBLK_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDBLK *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDBLK *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ENDBLK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDBLK *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ENDBLK", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ENDBLK *)calloc(1, sizeof(struct _dwg_entity_ENDBLK));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDBLK, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ENDBLK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDBLK *arg1 = (struct _dwg_entity_ENDBLK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDBLK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ENDBLK" "', argument " "1"" of type '" "struct _dwg_entity_ENDBLK *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDBLK *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ENDBLK_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ENDBLK, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ENDBLK_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SEQEND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *arg1 = (struct _dwg_entity_SEQEND *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SEQEND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SEQEND_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SEQEND *""'"); 
  }
  arg1 = (struct _dwg_entity_SEQEND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SEQEND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SEQEND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *arg1 = (struct _dwg_entity_SEQEND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SEQEND_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SEQEND *""'"); 
  }
  arg1 = (struct _dwg_entity_SEQEND *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SEQEND_begin_addr_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *arg1 = (struct _dwg_entity_SEQEND *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SEQEND_begin_addr_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SEQEND_begin_addr_r11_set" "', argument " "1"" of type '" "struct _dwg_entity_SEQEND *""'"); 
  }
  arg1 = (struct _dwg_entity_SEQEND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SEQEND_begin_addr_r11_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->begin_addr_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SEQEND_begin_addr_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *arg1 = (struct _dwg_entity_SEQEND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SEQEND_begin_addr_r11_get" "', argument " "1"" of type '" "struct _dwg_entity_SEQEND *""'"); 
  }
  arg1 = (struct _dwg_entity_SEQEND *)(argp1);
  result = (BITCODE_RL) ((arg1)->begin_addr_r11);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SEQEND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SEQEND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SEQEND *)calloc(1, sizeof(struct _dwg_entity_SEQEND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SEQEND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SEQEND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SEQEND *arg1 = (struct _dwg_entity_SEQEND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SEQEND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SEQEND" "', argument " "1"" of type '" "struct _dwg_entity_SEQEND *""'"); 
  }
  arg1 = (struct _dwg_entity_SEQEND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SEQEND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SEQEND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SEQEND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_scale_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_scale_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_scale_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_scale_flag_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->scale_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_scale_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_scale_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_BB) ((arg1)->scale_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_scale_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_has_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_has_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_has_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_has_attribs_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_has_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_has_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_B) ((arg1)->has_attribs);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_block_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_block_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_block_header_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_block_header_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_header = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_block_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_block_header_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->block_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_first_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_first_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_first_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_first_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_first_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_first_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->first_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_last_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_last_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_last_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_last_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_last_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_last_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->last_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_attribs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_H *) ((arg1)->attribs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_cols_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_num_cols_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_cols_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_rows_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_num_rows_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_num_rows_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_col_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_col_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_col_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_col_spacing_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->col_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_col_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_col_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_RD) ((arg1)->col_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_row_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_row_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_row_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_INSERT_row_spacing_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->row_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_row_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_row_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_RD) ((arg1)->row_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_block_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_INSERT_block_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_block_name_set" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_INSERT_block_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->block_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->block_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->block_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_INSERT_block_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_INSERT_block_name_get" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  result = (BITCODE_TV) ((arg1)->block_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_INSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_INSERT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_INSERT *)calloc(1, sizeof(struct _dwg_entity_INSERT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_INSERT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_INSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_INSERT *arg1 = (struct _dwg_entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_INSERT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_INSERT" "', argument " "1"" of type '" "struct _dwg_entity_INSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_INSERT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_INSERT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_INSERT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_INSERT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_scale_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_scale_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_scale_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_scale_flag_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->scale_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_scale_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_scale_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BB) ((arg1)->scale_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_scale_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_has_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_has_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_has_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_has_attribs_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_has_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_has_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_B) ((arg1)->has_attribs);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_cols_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_num_cols_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_cols_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_rows_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_num_rows_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_num_rows_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_col_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_col_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_col_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_col_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->col_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_col_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_col_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BD) ((arg1)->col_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_row_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_row_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_row_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MINSERT_row_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->row_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_row_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_row_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_BD) ((arg1)->row_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_block_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_block_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_block_header_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_block_header_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_header = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_block_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_block_header_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->block_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_first_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_first_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_first_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_first_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_first_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_first_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->first_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_last_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_last_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_last_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_last_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_last_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_last_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->last_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_attribs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_H *) ((arg1)->attribs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MINSERT_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MINSERT_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MINSERT_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MINSERT_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MINSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MINSERT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MINSERT *)calloc(1, sizeof(struct _dwg_entity_MINSERT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MINSERT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MINSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MINSERT *arg1 = (struct _dwg_entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MINSERT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MINSERT" "', argument " "1"" of type '" "struct _dwg_entity_MINSERT *""'"); 
  }
  arg1 = (struct _dwg_entity_MINSERT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MINSERT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MINSERT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MINSERT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_2D_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_point_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_2D_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_point_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_start_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_start_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_start_width_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_start_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_start_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_start_width_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_end_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_end_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_end_width_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_end_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_end_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_end_width_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_id_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_id_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_BL) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_bulge_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_bulge_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_bulge_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_bulge_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bulge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_bulge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_bulge_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->bulge);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_tangent_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_2D_tangent_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_tangent_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_2D_tangent_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->tangent_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_2D_tangent_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_2D_tangent_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->tangent_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VERTEX_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VERTEX_2D", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VERTEX_2D *)calloc(1, sizeof(struct _dwg_entity_VERTEX_2D));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VERTEX_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_2D *arg1 = (struct _dwg_entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VERTEX_2D" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_2D *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VERTEX_2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VERTEX_2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VERTEX_2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_3D_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_3D_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_3D_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_3D_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_3D_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_point_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_3D_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_3D_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_3D_point_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VERTEX_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VERTEX_3D", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VERTEX_3D *)calloc(1, sizeof(struct _dwg_entity_VERTEX_3D));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VERTEX_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_3D *arg1 = (struct _dwg_entity_VERTEX_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VERTEX_3D" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_3D *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VERTEX_3D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VERTEX_3D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_PFACE_FACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_PFACE_FACE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_vertind_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  BITCODE_BSd *arg2 = (BITCODE_BSd *) (BITCODE_BSd *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VERTEX_PFACE_FACE_vertind_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_vertind_set" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_vertind_set" "', argument " "2"" of type '" "BITCODE_BSd [4]""'"); 
  } 
  arg2 = (BITCODE_BSd *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) *(BITCODE_BSd *)&arg1->vertind[ii] = *((BITCODE_BSd *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""vertind""' of type '""BITCODE_BSd [4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VERTEX_PFACE_FACE_vertind_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VERTEX_PFACE_FACE_vertind_get" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  result = (BITCODE_BSd *)(BITCODE_BSd *) ((arg1)->vertind);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VERTEX_PFACE_FACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VERTEX_PFACE_FACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VERTEX_PFACE_FACE *)calloc(1, sizeof(struct _dwg_entity_VERTEX_PFACE_FACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VERTEX_PFACE_FACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VERTEX_PFACE_FACE *arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VERTEX_PFACE_FACE" "', argument " "1"" of type '" "struct _dwg_entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg1 = (struct _dwg_entity_VERTEX_PFACE_FACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VERTEX_PFACE_FACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VERTEX_PFACE_FACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_has_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_has_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_has_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_has_vertex_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_has_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_has_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_B) ((arg1)->has_vertex);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_first_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_first_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_first_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_first_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_first_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_first_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_H) ((arg1)->first_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_last_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_last_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_last_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_last_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_last_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_last_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_H) ((arg1)->last_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_vertex_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_H *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_curve_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_curve_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_curve_type_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_curve_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->curve_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_curve_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_curve_type_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BS) ((arg1)->curve_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_start_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_start_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_start_width_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_start_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_start_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_start_width_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_end_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_end_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_end_width_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_end_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_end_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_end_width_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extra_r11_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_extra_r11_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_size_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->extra_r11_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extra_r11_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_size_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BL) ((arg1)->extra_r11_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extra_r11_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_extra_r11_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_text_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->extra_r11_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->extra_r11_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->extra_r11_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_extra_r11_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_extra_r11_text_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_TV) ((arg1)->extra_r11_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_m_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_num_m_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_m_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_num_m_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_m_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_m_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_m_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_m_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_n_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_2D_num_n_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_n_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_2D_num_n_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_n_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_2D_num_n_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_2D_num_n_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_n_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POLYLINE_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POLYLINE_2D", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POLYLINE_2D *)calloc(1, sizeof(struct _dwg_entity_POLYLINE_2D));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_2D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POLYLINE_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_2D *arg1 = (struct _dwg_entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POLYLINE_2D" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_2D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_2D *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POLYLINE_2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POLYLINE_2D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POLYLINE_2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_has_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_has_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_has_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_has_vertex_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_has_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_has_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_B) ((arg1)->has_vertex);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_first_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_first_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_first_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_first_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_first_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_first_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_H) ((arg1)->first_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_last_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_last_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_last_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_last_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_last_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_last_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_H) ((arg1)->last_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_vertex_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_H *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_curve_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_curve_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_curve_type_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_curve_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->curve_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_curve_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_curve_type_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_RC) ((arg1)->curve_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_start_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_start_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_start_width_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_start_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_start_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_start_width_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_end_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_end_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_end_width_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_end_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_end_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_end_width_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_3D_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_3D_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_3D_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_3D_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_3D_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POLYLINE_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POLYLINE_3D", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POLYLINE_3D *)calloc(1, sizeof(struct _dwg_entity_POLYLINE_3D));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_3D, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POLYLINE_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_3D *arg1 = (struct _dwg_entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POLYLINE_3D" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_3D *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_3D *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POLYLINE_3D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POLYLINE_3D, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POLYLINE_3D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_center_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_center_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_start_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_start_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_end_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_end_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_end_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_end_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_end_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_end_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ARC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ARC", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ARC *)calloc(1, sizeof(struct _dwg_entity_ARC));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ARC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC *arg1 = (struct _dwg_entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ARC" "', argument " "1"" of type '" "struct _dwg_entity_ARC *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ARC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ARC, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ARC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CIRCLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_CIRCLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CIRCLE_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_center_set" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_CIRCLE_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_center_get" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CIRCLE_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_CIRCLE_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CIRCLE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_CIRCLE_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CIRCLE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_CIRCLE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CIRCLE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CIRCLE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_CIRCLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_CIRCLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_CIRCLE *)calloc(1, sizeof(struct _dwg_entity_CIRCLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CIRCLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_CIRCLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CIRCLE *arg1 = (struct _dwg_entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CIRCLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_CIRCLE" "', argument " "1"" of type '" "struct _dwg_entity_CIRCLE *""'"); 
  }
  arg1 = (struct _dwg_entity_CIRCLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_CIRCLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_CIRCLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_CIRCLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_z_is_zero_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_z_is_zero_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_z_is_zero_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LINE_z_is_zero_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->z_is_zero = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_z_is_zero_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_z_is_zero_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->z_is_zero);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_start_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINE_start_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->start = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_start_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->start);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_end_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINE_end_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->end = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_end_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->end);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LINE_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_unknown_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINE_unknown_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_unknown_r11_set" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINE_unknown_r11_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->unknown_r11 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINE_unknown_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINE_unknown_r11_get" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->unknown_r11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LINE *)calloc(1, sizeof(struct _dwg_entity_LINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINE *arg1 = (struct _dwg_entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LINE" "', argument " "1"" of type '" "struct _dwg_entity_LINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_parent_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_parent_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_class_version_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_class_version_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_extrusion_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_extrusion_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_def_pt_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_def_pt_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_elevation_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_elevation_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flag_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flag_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flag1_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flag1_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_user_text_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_user_text_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_attachment_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_attachment_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_unknown_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_unknown_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMENSION_common_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMENSION_common_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_block_set" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMENSION_common_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMENSION_common_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMENSION_common_block_get" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DIMENSION_common(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DIMENSION_common", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_DIMENSION_common *)calloc(1, sizeof(struct _dwg_DIMENSION_common));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DIMENSION_common, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DIMENSION_common(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMENSION_common *arg1 = (struct _dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMENSION_common, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DIMENSION_common" "', argument " "1"" of type '" "struct _dwg_DIMENSION_common *""'"); 
  }
  arg1 = (struct _dwg_DIMENSION_common *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DIMENSION_common_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_DIMENSION_common, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DIMENSION_common_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->feature_location_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->feature_location_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->leader_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->leader_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ORDINATE_flag2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag2_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ORDINATE_flag2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ORDINATE_flag2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_ORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_ORDINATE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_ORDINATE *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_ORDINATE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_ORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ORDINATE *arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_ORDINATE" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ORDINATE *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ORDINATE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ORDINATE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ORDINATE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_xline1_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_xline2_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->dim_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_LINEAR_dim_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  result = (BITCODE_BD) ((arg1)->dim_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_LINEAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_LINEAR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_LINEAR *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_LINEAR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_LINEAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_LINEAR *arg1 = (struct _dwg_entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_LINEAR" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_LINEAR *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_LINEAR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_LINEAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_LINEAR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  result = (BITCODE_BD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_ALIGNED(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_ALIGNED", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_ALIGNED *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_ALIGNED));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_ALIGNED(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ALIGNED *arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_ALIGNED" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ALIGNED *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ALIGNED *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ALIGNED_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ALIGNED_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_center_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_center_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_center_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_center_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_center_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_center_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->xline2end_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->xline2end_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_ANG3PT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_ANG3PT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_ANG3PT *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_ANG3PT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_ANG3PT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG3PT *arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_ANG3PT" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG3PT *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG3PT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ANG3PT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ANG3PT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1start_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1start_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1end_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1end_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2start_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2start_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2end_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2end_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_ANG2LN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_ANG2LN", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_ANG2LN *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_ANG2LN));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_ANG2LN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_ANG2LN *arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_ANG2LN" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_ANG2LN *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_ANG2LN *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ANG2LN_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_ANG2LN_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->first_arc_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->first_arc_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_leader_len_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_RADIUS_leader_len_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_leader_len_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_RADIUS_leader_len_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->leader_len = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_RADIUS_leader_len_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_RADIUS_leader_len_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  result = (BITCODE_BD) ((arg1)->leader_len);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_RADIUS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_RADIUS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_RADIUS *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_RADIUS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_RADIUS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_RADIUS *arg1 = (struct _dwg_entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_RADIUS" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_RADIUS *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_RADIUS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_RADIUS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_RADIUS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_block_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_block_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->first_arc_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->first_arc_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_leader_len_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_DIMENSION_DIAMETER_leader_len_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_leader_len_set" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_leader_len_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->leader_len = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_DIMENSION_DIAMETER_leader_len_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_DIMENSION_DIAMETER_leader_len_get" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->leader_len);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_DIMENSION_DIAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_DIMENSION_DIAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_DIMENSION_DIAMETER *)calloc(1, sizeof(struct _dwg_entity_DIMENSION_DIAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_DIMENSION_DIAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_DIMENSION_DIAMETER *arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_DIMENSION_DIAMETER" "', argument " "1"" of type '" "struct _dwg_entity_DIMENSION_DIAMETER *""'"); 
  }
  arg1 = (struct _dwg_entity_DIMENSION_DIAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_DIMENSION_DIAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_DIMENSION_DIAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_block_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_block_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_xline1_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_xline1_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_xline1_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_xline1_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline1_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_xline1_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_xline1_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline1_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_xline2_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_xline2_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_xline2_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_xline2_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->xline2_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_xline2_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_xline2_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->xline2_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_center_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_center_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_center_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_center_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_center_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_center_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_is_partial_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_is_partial_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_is_partial_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_is_partial_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_partial = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_is_partial_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_is_partial_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->is_partial);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_arc_start_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_arc_start_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_start_param_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_start_param_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arc_start_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_arc_start_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_start_param_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->arc_start_param);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_arc_end_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_arc_end_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_end_param_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_end_param_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arc_end_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_arc_end_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_arc_end_param_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->arc_end_param);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_has_leader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_has_leader_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_has_leader_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARC_DIMENSION_has_leader_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_leader = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_has_leader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_has_leader_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->has_leader);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_leader1_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_leader1_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_leader1_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_leader1_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->leader1_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_leader1_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_leader1_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->leader1_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_leader2_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARC_DIMENSION_leader2_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_leader2_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARC_DIMENSION_leader2_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->leader2_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARC_DIMENSION_leader2_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARC_DIMENSION_leader2_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->leader2_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ARC_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ARC_DIMENSION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ARC_DIMENSION *)calloc(1, sizeof(struct _dwg_entity_ARC_DIMENSION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC_DIMENSION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ARC_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARC_DIMENSION *arg1 = (struct _dwg_entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ARC_DIMENSION" "', argument " "1"" of type '" "struct _dwg_entity_ARC_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_ARC_DIMENSION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ARC_DIMENSION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ARC_DIMENSION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ARC_DIMENSION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->text_midpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->text_midpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->user_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->user_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->user_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_TV) ((arg1)->user_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_dir);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ins_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->ins_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lspace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BS) ((arg1)->lspace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lspace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->lspace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->act_measurement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->act_measurement);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clone_ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->clone_ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->jog_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_BD) ((arg1)->jog_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->jog_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->jog_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ovr_center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ovr_center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->chord_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->chord_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LARGE_RADIAL_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LARGE_RADIAL_DIMENSION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)calloc(1, sizeof(struct _dwg_entity_LARGE_RADIAL_DIMENSION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LARGE_RADIAL_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LARGE_RADIAL_DIMENSION *arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LARGE_RADIAL_DIMENSION" "', argument " "1"" of type '" "struct _dwg_entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg1 = (struct _dwg_entity_LARGE_RADIAL_DIMENSION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LARGE_RADIAL_DIMENSION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LARGE_RADIAL_DIMENSION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_x_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINT_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_x_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BD) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_y_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINT_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_y_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BD) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_z_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINT_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_z_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BD) ((arg1)->z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINT_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_x_ang_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINT_x_ang_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_x_ang_set" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINT_x_ang_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x_ang = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINT_x_ang_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINT_x_ang_get" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  result = (BITCODE_BD) ((arg1)->x_ang);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POINT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POINT *)calloc(1, sizeof(struct _dwg_entity_POINT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINT *arg1 = (struct _dwg_entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POINT" "', argument " "1"" of type '" "struct _dwg_entity_POINT *""'"); 
  }
  arg1 = (struct _dwg_entity_POINT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POINT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POINT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POINT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_has_no_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_has_no_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_has_no_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DFACE_has_no_flags_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_no_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_has_no_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_has_no_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_no_flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_z_is_zero_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_z_is_zero_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_z_is_zero_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DFACE_z_is_zero_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->z_is_zero = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_z_is_zero_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_z_is_zero_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->z_is_zero);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_corner1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner1_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DFACE_corner1_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->corner1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner1_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->corner1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_corner2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner2_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DFACE_corner2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->corner2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner2_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->corner2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_corner3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner3_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DFACE_corner3_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->corner3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner3_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->corner3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_corner4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner4_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DFACE_corner4_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->corner4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_corner4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_corner4_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->corner4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_invis_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DFACE_invis_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_invis_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DFACE_invis_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->invis_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DFACE_invis_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DFACE_invis_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->invis_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity__3DFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity__3DFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_3DFACE *)calloc(1, sizeof(struct _dwg_entity_3DFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity__3DFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DFACE *arg1 = (struct _dwg_entity_3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity__3DFACE" "', argument " "1"" of type '" "struct _dwg_entity_3DFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity__3DFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_3DFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity__3DFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_PFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_has_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_has_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_has_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_PFACE_has_vertex_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_has_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_has_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_vertex);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_PFACE_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_first_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_first_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_first_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_PFACE_first_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_first_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_first_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->first_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_last_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_last_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_last_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_PFACE_last_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_last_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_last_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->last_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_PFACE_vertex_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_H *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_PFACE_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_PFACE_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_numverts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_numverts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_numverts_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_PFACE_numverts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->numverts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_numverts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_numverts_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->numverts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_numfaces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_PFACE_numfaces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_numfaces_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_PFACE_numfaces_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->numfaces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_PFACE_numfaces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_PFACE_numfaces_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->numfaces);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POLYLINE_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POLYLINE_PFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POLYLINE_PFACE *)calloc(1, sizeof(struct _dwg_entity_POLYLINE_PFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POLYLINE_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_PFACE *arg1 = (struct _dwg_entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POLYLINE_PFACE" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_PFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_PFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POLYLINE_PFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POLYLINE_PFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_MESH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_has_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_has_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_has_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_has_vertex_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_has_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_has_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_B) ((arg1)->has_vertex);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_first_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_first_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_first_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_MESH_first_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_first_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_first_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_H) ((arg1)->first_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_last_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_last_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_last_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_MESH_last_vertex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_last_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_last_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_H) ((arg1)->last_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_MESH_vertex_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_H *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLYLINE_MESH_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_curve_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_curve_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_curve_type_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_curve_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->curve_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_curve_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_curve_type_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->curve_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_m_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_num_m_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_m_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_num_m_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_m_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_m_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_m_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_m_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_n_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_num_n_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_n_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_num_n_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_n_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_num_n_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_num_n_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_n_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_m_density_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_m_density_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_m_density_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_m_density_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->m_density = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_m_density_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_m_density_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->m_density);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_n_density_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLYLINE_MESH_n_density_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_n_density_set" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POLYLINE_MESH_n_density_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->n_density = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLYLINE_MESH_n_density_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLYLINE_MESH_n_density_get" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->n_density);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POLYLINE_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POLYLINE_MESH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POLYLINE_MESH *)calloc(1, sizeof(struct _dwg_entity_POLYLINE_MESH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_MESH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POLYLINE_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLYLINE_MESH *arg1 = (struct _dwg_entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POLYLINE_MESH" "', argument " "1"" of type '" "struct _dwg_entity_POLYLINE_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_POLYLINE_MESH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POLYLINE_MESH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POLYLINE_MESH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POLYLINE_MESH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SOLID_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SOLID_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_corner1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner1_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_corner1_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner1_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_corner2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner2_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_corner2_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner2_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_corner3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner3_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_corner3_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner3_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_corner4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner4_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_corner4_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_corner4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_corner4_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SOLID_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SOLID_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SOLID_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SOLID_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SOLID", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SOLID *)calloc(1, sizeof(struct _dwg_entity_SOLID));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SOLID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SOLID *arg1 = (struct _dwg_entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SOLID" "', argument " "1"" of type '" "struct _dwg_entity_SOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_SOLID *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SOLID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SOLID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SOLID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_BT arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TRACE_thickness_set" "', argument " "2"" of type '" "BITCODE_BT""'");
  } 
  arg2 = (BITCODE_BT)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BT result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_BT) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TRACE_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_corner1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner1_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_corner1_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner1_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_corner2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner2_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_corner2_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner2_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_corner3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner3_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_corner3_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner3_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_corner4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner4_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_corner4_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->corner4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_corner4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_corner4_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->corner4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TRACE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TRACE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TRACE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TRACE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_TRACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_TRACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_TRACE *)calloc(1, sizeof(struct _dwg_entity_TRACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TRACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_TRACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TRACE *arg1 = (struct _dwg_entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TRACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_TRACE" "', argument " "1"" of type '" "struct _dwg_entity_TRACE *""'"); 
  }
  arg1 = (struct _dwg_entity_TRACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_TRACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_TRACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_TRACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SHAPE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SHAPE_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_width_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_width_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_width_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_width_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_width_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_width_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->width_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_thickness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_style_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_style_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_style_id_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SHAPE_style_id_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->style_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_style_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_style_id_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BS) ((arg1)->style_id);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SHAPE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SHAPE_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_style_set" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SHAPE_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SHAPE_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SHAPE_style_get" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SHAPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SHAPE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SHAPE *)calloc(1, sizeof(struct _dwg_entity_SHAPE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SHAPE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SHAPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SHAPE *arg1 = (struct _dwg_entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SHAPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SHAPE" "', argument " "1"" of type '" "struct _dwg_entity_SHAPE *""'"); 
  }
  arg1 = (struct _dwg_entity_SHAPE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SHAPE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SHAPE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SHAPE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_center_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_center_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_width_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_width_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_height_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_height_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_on_off_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_on_off_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_on_off_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_on_off_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->on_off = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_on_off_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_on_off_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_RS) ((arg1)->on_off);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_id_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_id_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_id_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_RS) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_view_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_view_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_view_target_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_view_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->view_target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_view_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_view_target_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->view_target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_VIEWDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWDIR_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_VIEWDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->VIEWDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWDIR_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->VIEWDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_VIEWSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWSIZE_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_VIEWSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->VIEWSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWSIZE_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->VIEWSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_lens_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_lens_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_lens_length_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_lens_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lens_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_lens_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_lens_length_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->lens_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_front_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_front_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_front_clip_z_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_front_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->front_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_front_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_front_clip_z_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->front_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_back_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_back_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_back_clip_z_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_back_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->back_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_back_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_back_clip_z_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->back_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPANG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_SNAPANG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPANG_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_SNAPANG_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->SNAPANG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPANG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPANG_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->SNAPANG);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWCTR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_VIEWCTR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWCTR_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_VIEWCTR_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->VIEWCTR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_VIEWCTR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_VIEWCTR_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->VIEWCTR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_SNAPBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPBASE_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_SNAPBASE_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPBASE_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_SNAPUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPUNIT_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_SNAPUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_SNAPUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_SNAPUNIT_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_GRIDUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_GRIDUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_GRIDUNIT_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_GRIDUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->GRIDUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_GRIDUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_GRIDUNIT_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->GRIDUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_circle_zoom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_circle_zoom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_circle_zoom_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_circle_zoom_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->circle_zoom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_circle_zoom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_circle_zoom_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->circle_zoom);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_grid_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_grid_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_grid_major_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_grid_major_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->grid_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_grid_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_grid_major_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->grid_major);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_num_frozen_layers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_num_frozen_layers_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_num_frozen_layers_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_num_frozen_layers_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_frozen_layers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_num_frozen_layers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_num_frozen_layers_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_frozen_layers);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_status_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_status_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_status_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_status_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->status_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_status_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_status_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BL) ((arg1)->status_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_style_sheet_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_style_sheet_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_style_sheet_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_style_sheet_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->style_sheet);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->style_sheet = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->style_sheet = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_style_sheet_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_style_sheet_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_TV) ((arg1)->style_sheet);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_render_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_render_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_render_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_render_mode_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->render_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_render_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_render_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->render_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucs_at_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ucs_at_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucs_at_origin_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_ucs_at_origin_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ucs_at_origin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucs_at_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucs_at_origin_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->ucs_at_origin);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_UCSVP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_UCSVP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_UCSVP_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_UCSVP_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->UCSVP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_UCSVP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_UCSVP_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->UCSVP);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsorg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ucsorg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsorg_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_ucsorg_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsorg = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsorg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsorg_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsorg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsxdir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ucsxdir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsxdir_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_ucsxdir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsxdir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsxdir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsxdir_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsxdir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsydir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ucsydir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsydir_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_ucsydir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsydir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucsydir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucsydir_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsydir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucs_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ucs_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucs_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_ucs_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ucs_elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ucs_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ucs_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->ucs_elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_shadeplot_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_shadeplot_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadeplot_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_shadeplot_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadeplot_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_use_default_lights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_use_default_lights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_use_default_lights_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_use_default_lights_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_default_lights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_use_default_lights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_use_default_lights_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->use_default_lights);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_default_lighting_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_default_lighting_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_default_lighting_type_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_default_lighting_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->default_lighting_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_default_lighting_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_default_lighting_type_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->default_lighting_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_brightness_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_brightness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_brightness_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->brightness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_contrast_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_VIEWPORT_contrast_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_contrast_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->contrast);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ambient_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_ambient_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ambient_color_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_ambient_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->ambient_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_ambient_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_ambient_color_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->ambient_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_vport_entity_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_vport_entity_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_vport_entity_header_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_vport_entity_header_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->vport_entity_header = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_vport_entity_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_vport_entity_header_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->vport_entity_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_frozen_layers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_frozen_layers_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_frozen_layers_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_frozen_layers_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->frozen_layers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_frozen_layers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_frozen_layers_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H *) ((arg1)->frozen_layers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_clip_boundary_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_clip_boundary_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_clip_boundary_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_clip_boundary_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->clip_boundary = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_clip_boundary_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_clip_boundary_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->clip_boundary);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_named_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_named_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_named_ucs_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_named_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->named_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_named_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_named_ucs_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->named_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_base_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_base_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_base_ucs_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_base_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->base_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_base_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_base_ucs_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->base_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_background_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_background_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_background_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_background_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->background = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_background_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_background_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->background);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_shadeplot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_shadeplot_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->shadeplot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_shadeplot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_shadeplot_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->shadeplot);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_sun_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VIEWPORT_sun_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_sun_set" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VIEWPORT_sun_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VIEWPORT_sun_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VIEWPORT_sun_get" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->sun);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VIEWPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VIEWPORT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VIEWPORT *)calloc(1, sizeof(struct _dwg_entity_VIEWPORT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VIEWPORT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VIEWPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VIEWPORT *arg1 = (struct _dwg_entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VIEWPORT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VIEWPORT" "', argument " "1"" of type '" "struct _dwg_entity_VIEWPORT *""'"); 
  }
  arg1 = (struct _dwg_entity_VIEWPORT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VIEWPORT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VIEWPORT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VIEWPORT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ELLIPSE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_center_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ELLIPSE_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_center_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_sm_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_sm_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_sm_axis_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ELLIPSE_sm_axis_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->sm_axis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_sm_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_sm_axis_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->sm_axis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ELLIPSE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_axis_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_axis_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_axis_ratio_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ELLIPSE_axis_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->axis_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_axis_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_axis_ratio_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_BD) ((arg1)->axis_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_start_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ELLIPSE_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_start_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_end_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ELLIPSE_end_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_end_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ELLIPSE_end_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ELLIPSE_end_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ELLIPSE_end_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ELLIPSE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ELLIPSE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ELLIPSE *)calloc(1, sizeof(struct _dwg_entity_ELLIPSE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ELLIPSE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ELLIPSE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ELLIPSE *arg1 = (struct _dwg_entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ELLIPSE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ELLIPSE" "', argument " "1"" of type '" "struct _dwg_entity_ELLIPSE *""'"); 
  }
  arg1 = (struct _dwg_entity_ELLIPSE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ELLIPSE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ELLIPSE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ELLIPSE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  struct _dwg_entity_SPLINE *arg2 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SPLINE_control_point_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_parent_set" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SPLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SPLINE_control_point_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg2 = (struct _dwg_entity_SPLINE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_SPLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_parent_get" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  result = (struct _dwg_entity_SPLINE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SPLINE_control_point_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_x_set" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SPLINE_control_point_x_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_x_get" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  result = (double) ((arg1)->x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SPLINE_control_point_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_y_set" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SPLINE_control_point_y_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_y_get" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  result = (double) ((arg1)->y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SPLINE_control_point_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_z_set" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SPLINE_control_point_z_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_z_get" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  result = (double) ((arg1)->z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_w_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SPLINE_control_point_w_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_w_set" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SPLINE_control_point_w_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (arg1) (arg1)->w = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SPLINE_control_point_w_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SPLINE_control_point_w_get" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  result = (double) ((arg1)->w);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SPLINE_control_point(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SPLINE_control_point", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_SPLINE_control_point *)calloc(1, sizeof(struct _dwg_SPLINE_control_point));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SPLINE_control_point, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SPLINE_control_point(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SPLINE_control_point *arg1 = (struct _dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SPLINE_control_point, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SPLINE_control_point" "', argument " "1"" of type '" "struct _dwg_SPLINE_control_point *""'"); 
  }
  arg1 = (struct _dwg_SPLINE_control_point *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SPLINE_control_point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_SPLINE_control_point, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SPLINE_control_point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_flag_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_RS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_scenario_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_scenario_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_scenario_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_scenario_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->scenario = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_scenario_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_scenario_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->scenario);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_degree_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_degree_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_degree_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_degree_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->degree = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_degree_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_degree_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->degree);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_splineflags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_splineflags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_splineflags_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_splineflags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->splineflags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_splineflags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_splineflags_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->splineflags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knotparam_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_knotparam_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knotparam_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_knotparam_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->knotparam = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knotparam_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knotparam_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->knotparam);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_fit_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_fit_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_fit_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_fit_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fit_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_fit_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_fit_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->fit_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_beg_tan_vec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_beg_tan_vec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_beg_tan_vec_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_beg_tan_vec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->beg_tan_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_beg_tan_vec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_beg_tan_vec_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->beg_tan_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_end_tan_vec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_end_tan_vec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_end_tan_vec_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_end_tan_vec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->end_tan_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_end_tan_vec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_end_tan_vec_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->end_tan_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_closed_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_closed_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_closed_b_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_closed_b_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->closed_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_closed_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_closed_b_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_B) ((arg1)->closed_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_periodic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_periodic_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_periodic_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_periodic_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->periodic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_periodic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_periodic_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_B) ((arg1)->periodic);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_rational_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_rational_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_rational_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_rational_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->rational = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_rational_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_rational_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_B) ((arg1)->rational);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_weighted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_weighted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_weighted_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_weighted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->weighted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_weighted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_weighted_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_B) ((arg1)->weighted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knot_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_knot_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knot_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_knot_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->knot_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knot_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knot_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->knot_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_ctrl_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_ctrl_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_ctrl_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_ctrl_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ctrl_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_ctrl_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_ctrl_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->ctrl_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_fit_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_num_fit_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_fit_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_num_fit_pts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_fit_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_fit_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_fit_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_fit_pts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_fit_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_fit_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_fit_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_fit_pts_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->fit_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_fit_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_fit_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->fit_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_num_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_knots_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_num_knots_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_knots_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_knots);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knots_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_knots_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_knots_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->knots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_ctrl_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_num_ctrl_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_ctrl_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SPLINE_num_ctrl_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_ctrl_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_num_ctrl_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_num_ctrl_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_ctrl_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_ctrl_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  Dwg_SPLINE_control_point *arg2 = (Dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SPLINE_ctrl_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_ctrl_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SPLINE_control_point, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SPLINE_ctrl_pts_set" "', argument " "2"" of type '" "Dwg_SPLINE_control_point *""'"); 
  }
  arg2 = (Dwg_SPLINE_control_point *)(argp2);
  if (arg1) (arg1)->ctrl_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SPLINE_ctrl_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SPLINE_control_point *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SPLINE_ctrl_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  result = (Dwg_SPLINE_control_point *) ((arg1)->ctrl_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SPLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SPLINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SPLINE *)calloc(1, sizeof(struct _dwg_entity_SPLINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SPLINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SPLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SPLINE *arg1 = (struct _dwg_entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SPLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SPLINE" "', argument " "1"" of type '" "struct _dwg_entity_SPLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_SPLINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SPLINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SPLINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SPLINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_parent_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_parent_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_type_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_type_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_RC) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_selection_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_selection_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_selection_marker_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_selection_marker_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->selection_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_selection_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_selection_marker_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_BLd) ((arg1)->selection_marker);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_color_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_color_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->color = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_color_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_BL) ((arg1)->color);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_acis_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_acis_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_acis_index_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_acis_index_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->acis_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_acis_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_acis_index_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_BLd) ((arg1)->acis_index);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_num_points_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_num_points_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_points_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_points_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_points_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_transform_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_transform_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_transform_present_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_transform_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->transform_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_transform_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_transform_present_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_B) ((arg1)->transform_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_axis_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_x_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_axis_x_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_x_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_axis_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_y_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_axis_y_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_y_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_axis_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_z_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_axis_z_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_z = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_axis_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_axis_z_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_z);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_translation_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_translation_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_translation_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_scale_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_wire_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_scale_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_has_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_rotation_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_has_rotation_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_rotation_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_B) ((arg1)->has_rotation);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_reflection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_has_reflection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_reflection_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_has_reflection_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_reflection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_reflection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_reflection_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_B) ((arg1)->has_reflection);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_shear_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_wire_has_shear_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_shear_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_wire_has_shear_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_shear = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_wire_has_shear_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_wire_has_shear_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  result = (BITCODE_B) ((arg1)->has_shear);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_3DSOLID_wire(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_3DSOLID_wire", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_3DSOLID_wire *)calloc(1, sizeof(struct _dwg_3DSOLID_wire));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_3DSOLID_wire(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_wire *arg1 = (struct _dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_3DSOLID_wire" "', argument " "1"" of type '" "struct _dwg_3DSOLID_wire *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_wire *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_3DSOLID_wire_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_3DSOLID_wire_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_parent_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_silhouette_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_parent_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_vp_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_id_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_silhouette_vp_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->vp_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_id_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_BL) ((arg1)->vp_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_vp_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_target_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_silhouette_vp_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vp_target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_target_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vp_target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_dir_from_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_vp_dir_from_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_dir_from_target_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_silhouette_vp_dir_from_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vp_dir_from_target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_dir_from_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_dir_from_target_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vp_dir_from_target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_up_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_vp_up_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_up_dir_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_silhouette_vp_up_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vp_up_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_up_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_up_dir_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vp_up_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_perspective_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_vp_perspective_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_perspective_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_silhouette_vp_perspective_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->vp_perspective = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_vp_perspective_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_vp_perspective_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_B) ((arg1)->vp_perspective);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_has_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_has_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_has_wires_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_silhouette_has_wires_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_has_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_has_wires_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_B) ((arg1)->has_wires);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_num_wires_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_silhouette_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_num_wires_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_silhouette_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_wires_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_silhouette_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_silhouette_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_silhouette_wires_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_3DSOLID_silhouette(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_3DSOLID_silhouette", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_3DSOLID_silhouette *)calloc(1, sizeof(struct _dwg_3DSOLID_silhouette));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_3DSOLID_silhouette(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_silhouette *arg1 = (struct _dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_3DSOLID_silhouette" "', argument " "1"" of type '" "struct _dwg_3DSOLID_silhouette *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_silhouette *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_3DSOLID_silhouette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_3DSOLID_silhouette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_material_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_parent_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_material_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_parent_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_array_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_material_array_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_array_index_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_material_array_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->array_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_array_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_array_index_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  result = (BITCODE_BL) ((arg1)->array_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_mat_absref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_material_mat_absref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_mat_absref_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_3DSOLID_material_mat_absref_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->mat_absref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_mat_absref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_mat_absref_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  result = (BITCODE_BL) ((arg1)->mat_absref);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_material_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_3DSOLID_material_material_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_material_handle_set" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_3DSOLID_material_material_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->material_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_3DSOLID_material_material_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_3DSOLID_material_material_handle_get" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  result = (BITCODE_H) ((arg1)->material_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_3DSOLID_material(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_3DSOLID_material", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_3DSOLID_material *)calloc(1, sizeof(struct _dwg_3DSOLID_material));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_3DSOLID_material(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_3DSOLID_material *arg1 = (struct _dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_3DSOLID_material" "', argument " "1"" of type '" "struct _dwg_3DSOLID_material *""'"); 
  }
  arg1 = (struct _dwg_3DSOLID_material *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_3DSOLID_material_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_3DSOLID_material, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_3DSOLID_material_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_version_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_version_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_point_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_point_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DSOLID_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DSOLID_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DSOLID_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DSOLID_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DSOLID_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity__3DSOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity__3DSOLID", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_3DSOLID *)calloc(1, sizeof(struct _dwg_entity_3DSOLID));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity__3DSOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DSOLID *arg1 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity__3DSOLID" "', argument " "1"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg1 = (struct _dwg_entity_3DSOLID *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity__3DSOLID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity__3DSOLID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RAY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RAY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RAY_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_point_set" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RAY_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_point_get" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RAY_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_vector_set" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RAY_vector_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RAY_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RAY_vector_get" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_RAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_RAY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_RAY *)calloc(1, sizeof(struct _dwg_entity_RAY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RAY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_RAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RAY *arg1 = (struct _dwg_entity_RAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_RAY" "', argument " "1"" of type '" "struct _dwg_entity_RAY *""'"); 
  }
  arg1 = (struct _dwg_entity_RAY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_RAY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_RAY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_RAY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_numitems_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_numitems_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_numitems_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARY_numitems_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numitems = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_numitems_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_numitems_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numitems);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_is_hardowner_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_is_hardowner_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_is_hardowner_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARY_is_hardowner_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_hardowner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_is_hardowner_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_is_hardowner_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_hardowner);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_cloning_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_cloning_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_cloning_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARY_cloning_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->cloning = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_cloning_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_cloning_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (BITCODE_BS) ((arg1)->cloning);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_texts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_texts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_texts_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARY_texts_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->texts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_texts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_texts_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (BITCODE_TV *) ((arg1)->texts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_itemhandles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARY_itemhandles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_itemhandles_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARY_itemhandles_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->itemhandles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARY_itemhandles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARY_itemhandles_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  result = (BITCODE_H *) ((arg1)->itemhandles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DICTIONARY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DICTIONARY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DICTIONARY *)calloc(1, sizeof(struct _dwg_object_DICTIONARY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DICTIONARY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARY *arg1 = (struct _dwg_object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DICTIONARY" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARY *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DICTIONARY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DICTIONARY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DICTIONARY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYWDFLT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_numitems_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_numitems_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_numitems_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARYWDFLT_numitems_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numitems = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_numitems_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_numitems_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_BL) ((arg1)->numitems);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_is_hardowner_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_is_hardowner_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_is_hardowner_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARYWDFLT_is_hardowner_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_hardowner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_is_hardowner_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_is_hardowner_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_hardowner);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_cloning_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_cloning_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_cloning_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARYWDFLT_cloning_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->cloning = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_cloning_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_cloning_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_BS) ((arg1)->cloning);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_texts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_texts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_texts_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYWDFLT_texts_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->texts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_texts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_texts_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_TV *) ((arg1)->texts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_itemhandles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_itemhandles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_itemhandles_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYWDFLT_itemhandles_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->itemhandles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_itemhandles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_itemhandles_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_H *) ((arg1)->itemhandles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_defaultid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYWDFLT_defaultid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_defaultid_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYWDFLT_defaultid_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->defaultid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYWDFLT_defaultid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYWDFLT_defaultid_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  result = (BITCODE_H) ((arg1)->defaultid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DICTIONARYWDFLT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DICTIONARYWDFLT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DICTIONARYWDFLT *)calloc(1, sizeof(struct _dwg_object_DICTIONARYWDFLT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DICTIONARYWDFLT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYWDFLT *arg1 = (struct _dwg_object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DICTIONARYWDFLT" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYWDFLT *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYWDFLT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DICTIONARYWDFLT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DICTIONARYWDFLT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLEFRAME_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLEFRAME_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLEFRAME_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLEFRAME_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLEFRAME_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLEFRAME_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  result = (BITCODE_BS) ((arg1)->mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLEFRAME_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLEFRAME_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLEFRAME_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_data_set" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLEFRAME_data_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLEFRAME_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLEFRAME_data_get" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  result = (BITCODE_TF) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_OLEFRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_OLEFRAME", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_OLEFRAME *)calloc(1, sizeof(struct _dwg_entity_OLEFRAME));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLEFRAME, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_OLEFRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLEFRAME *arg1 = (struct _dwg_entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLEFRAME, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_OLEFRAME" "', argument " "1"" of type '" "struct _dwg_entity_OLEFRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLEFRAME *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_OLEFRAME_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_OLEFRAME, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_OLEFRAME_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_x_axis_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_x_axis_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_x_axis_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_x_axis_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->x_axis_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_x_axis_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_x_axis_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->x_axis_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_rect_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_rect_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_rect_height_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_rect_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_rect_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_rect_height_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_rect_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_rect_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_rect_width_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_rect_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_rect_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_rect_width_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_text_height_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_text_height_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_flow_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_flow_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_flow_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_flow_dir_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flow_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_flow_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_flow_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->flow_dir);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extents_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_extents_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extents_width_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_extents_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extents_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extents_width_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extents_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_extents_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extents_height_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_extents_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_extents_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_extents_height_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_text_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_text_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_style_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_style_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_linespace_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_linespace_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_linespace_style_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_linespace_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->linespace_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_linespace_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_linespace_style_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->linespace_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_linespace_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_linespace_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_linespace_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_linespace_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->linespace_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_linespace_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_linespace_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->linespace_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_unknown_b0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_unknown_b0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_unknown_b0_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_unknown_b0_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_unknown_b0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_unknown_b0_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b0);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_bg_fill_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_bg_fill_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_fill_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_fill_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_bg_fill_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_bg_fill_scale_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_fill_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_fill_scale);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_bg_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_color_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_bg_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bg_fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_color_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bg_fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_trans_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_bg_fill_trans_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_trans_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_bg_fill_trans_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_fill_trans = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_bg_fill_trans_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_bg_fill_trans_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_fill_trans);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_is_not_annotative_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_is_not_annotative_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_is_not_annotative_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_is_not_annotative_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_not_annotative = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_is_not_annotative_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_is_not_annotative_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_B) ((arg1)->is_not_annotative);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_default_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_default_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_default_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_default_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->default_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_default_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_default_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_B) ((arg1)->default_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_appid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_appid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_appid_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_appid_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->appid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_appid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_appid_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_H) ((arg1)->appid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_ignore_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_ignore_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_ignore_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_ignore_attachment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->ignore_attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_ignore_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_ignore_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->ignore_attachment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_column_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_type_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_column_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->column_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_type_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->column_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_numfragments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_numfragments_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_numfragments_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_numfragments_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numfragments = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_numfragments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_numfragments_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->numfragments);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_column_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_width_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_column_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->column_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_width_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->column_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_gutter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_gutter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_gutter_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_gutter_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gutter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_gutter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_gutter_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->gutter);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_auto_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_auto_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_auto_height_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_auto_height_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->auto_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_auto_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_auto_height_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_B) ((arg1)->auto_height);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_flow_reversed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_flow_reversed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_flow_reversed_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_flow_reversed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flow_reversed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_flow_reversed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_flow_reversed_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_B) ((arg1)->flow_reversed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_num_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_num_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_num_column_heights_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MTEXT_num_column_heights_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_num_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_num_column_heights_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_column_heights);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MTEXT_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_heights_set" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MTEXT_column_heights_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MTEXT_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MTEXT_column_heights_get" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  result = (BITCODE_BD *) ((arg1)->column_heights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MTEXT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MTEXT *)calloc(1, sizeof(struct _dwg_entity_MTEXT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MTEXT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MTEXT *arg1 = (struct _dwg_entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MTEXT" "', argument " "1"" of type '" "struct _dwg_entity_MTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_MTEXT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MTEXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MTEXT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MTEXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_bit_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_1_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_bit_1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bit_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_1_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bit_1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_path_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_path_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_path_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_path_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->path_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_path_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_path_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->path_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_annot_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_annot_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_annot_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_annot_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annot_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_annot_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_annot_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->annot_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_num_points_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_num_points_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_points_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_points_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_points_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_origin_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_origin_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_origin_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_x_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_x_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_x_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_x_direction_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->x_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_x_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_x_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->x_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_inspt_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_inspt_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_inspt_offset_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_inspt_offset_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->inspt_offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_inspt_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_inspt_offset_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->inspt_offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_endptproj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_endptproj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_endptproj_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_endptproj_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->endptproj = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_endptproj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_endptproj_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->endptproj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimgap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_dimgap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimgap_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_dimgap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->dimgap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimgap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimgap_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->dimgap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_box_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_box_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_box_height_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_box_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->box_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_box_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_box_height_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->box_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_box_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_box_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_box_width_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_box_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->box_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_box_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_box_width_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->box_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_hookline_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_hookline_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_hookline_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_hookline_dir_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->hookline_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_hookline_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_hookline_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->hookline_dir);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_hookline_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_hookline_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_hookline_on_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_hookline_on_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->hookline_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_hookline_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_hookline_on_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->hookline_on);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_arrowhead_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_arrowhead_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_arrowhead_on_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_arrowhead_on_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->arrowhead_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_arrowhead_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_arrowhead_on_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->arrowhead_on);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_arrowhead_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_arrowhead_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_arrowhead_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_arrowhead_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->arrowhead_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_arrowhead_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_arrowhead_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->arrowhead_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimasz_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_dimasz_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimasz_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_dimasz_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->dimasz = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimasz_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimasz_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->dimasz);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_bit_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_2_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_bit_2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bit_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_2_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bit_2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_bit_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_3_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_bit_3_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bit_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_3_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bit_3);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_short_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_short_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_short_1_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_short_1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_short_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_short_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_short_1_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_short_1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_byblock_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_byblock_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_byblock_color_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_byblock_color_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->byblock_color = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_byblock_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_byblock_color_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->byblock_color);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_bit_4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_4_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_bit_4_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bit_4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_4_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bit_4);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_unknown_bit_5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_5_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LEADER_unknown_bit_5_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bit_5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_unknown_bit_5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_unknown_bit_5_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bit_5);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_associated_annotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_associated_annotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_associated_annotation_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_associated_annotation_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->associated_annotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_associated_annotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_associated_annotation_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->associated_annotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LEADER_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LEADER_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LEADER_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LEADER_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LEADER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LEADER *)calloc(1, sizeof(struct _dwg_entity_LEADER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LEADER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LEADER *arg1 = (struct _dwg_entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LEADER" "', argument " "1"" of type '" "struct _dwg_entity_LEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_LEADER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LEADER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LEADER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LEADER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_unknown_short_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_unknown_short_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_unknown_short_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TOLERANCE_unknown_short_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_short = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_unknown_short_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_unknown_short_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_short);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_height_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TOLERANCE_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_height_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_dimgap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_dimgap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_dimgap_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TOLERANCE_dimgap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->dimgap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_dimgap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_dimgap_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_BD) ((arg1)->dimgap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_x_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_x_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_x_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_x_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->x_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_x_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_x_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->x_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_text_value_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_text_value_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_dimstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TOLERANCE_dimstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_dimstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TOLERANCE_dimstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TOLERANCE_dimstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TOLERANCE_dimstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  result = (BITCODE_H) ((arg1)->dimstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_TOLERANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_TOLERANCE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_TOLERANCE *)calloc(1, sizeof(struct _dwg_entity_TOLERANCE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TOLERANCE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_TOLERANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TOLERANCE *arg1 = (struct _dwg_entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TOLERANCE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_TOLERANCE" "', argument " "1"" of type '" "struct _dwg_entity_TOLERANCE *""'"); 
  }
  arg1 = (struct _dwg_entity_TOLERANCE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_TOLERANCE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_TOLERANCE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_TOLERANCE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  struct _dwg_MLINE_vertex *arg2 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_line_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_parent_set" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLINE_vertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_line_parent_set" "', argument " "2"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg2 = (struct _dwg_MLINE_vertex *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_MLINE_vertex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_parent_get" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  result = (struct _dwg_MLINE_vertex *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_num_segparms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_line_num_segparms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_num_segparms_set" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLINE_line_num_segparms_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_segparms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_num_segparms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_num_segparms_get" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_segparms);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_segparms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_line_segparms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_segparms_set" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_line_segparms_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->segparms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_segparms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_segparms_get" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  result = (BITCODE_BD *) ((arg1)->segparms);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_num_areafillparms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_line_num_areafillparms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_num_areafillparms_set" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLINE_line_num_areafillparms_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_areafillparms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_num_areafillparms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_num_areafillparms_get" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_areafillparms);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_areafillparms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_line_areafillparms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_areafillparms_set" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_line_areafillparms_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->areafillparms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_line_areafillparms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_line_areafillparms_get" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  result = (BITCODE_BD *) ((arg1)->areafillparms);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLINE_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLINE_line", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLINE_line *)calloc(1, sizeof(struct _dwg_MLINE_line));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINE_line, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLINE_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_line *arg1 = (struct _dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLINE_line" "', argument " "1"" of type '" "struct _dwg_MLINE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINE_line *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLINE_line_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLINE_line, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLINE_line_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  struct _dwg_entity_MLINE *arg2 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_parent_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_vertex_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg2 = (struct _dwg_entity_MLINE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_MLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_parent_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (struct _dwg_entity_MLINE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_vertex_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_vertex_vertex_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_vertex_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_vertex_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_vertex_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_vertex_direction_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_vertex_vertex_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vertex_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_vertex_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_vertex_direction_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vertex_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_miter_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_miter_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_miter_direction_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_vertex_miter_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->miter_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_miter_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_miter_direction_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->miter_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_num_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_num_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_num_lines_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLINE_vertex_num_lines_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->num_lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_num_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_num_lines_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (BITCODE_RC) ((arg1)->num_lines);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  Dwg_MLINE_line *arg2 = (Dwg_MLINE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINE_vertex_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_lines_set" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLINE_line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINE_vertex_lines_set" "', argument " "2"" of type '" "Dwg_MLINE_line *""'"); 
  }
  arg2 = (Dwg_MLINE_line *)(argp2);
  if (arg1) (arg1)->lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINE_vertex_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLINE_line *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINE_vertex_lines_get" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  result = (Dwg_MLINE_line *) ((arg1)->lines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINE_line, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLINE_vertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLINE_vertex", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLINE_vertex *)calloc(1, sizeof(struct _dwg_MLINE_vertex));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINE_vertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLINE_vertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINE_vertex *arg1 = (struct _dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINE_vertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLINE_vertex" "', argument " "1"" of type '" "struct _dwg_MLINE_vertex *""'"); 
  }
  arg1 = (struct _dwg_MLINE_vertex *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLINE_vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLINE_vertex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLINE_vertex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MLINE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MLINE_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_justification_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_justification_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_justification_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MLINE_justification_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->justification = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_justification_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_justification_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->justification);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_base_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_base_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_base_point_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MLINE_base_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_base_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_base_point_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MLINE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MLINE_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_num_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_num_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_num_lines_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MLINE_num_lines_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->num_lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_num_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_num_lines_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->num_lines);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_num_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_num_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_num_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MLINE_num_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_num_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_num_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  Dwg_MLINE_vertex *arg2 = (Dwg_MLINE_vertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLINE_vertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MLINE_verts_set" "', argument " "2"" of type '" "Dwg_MLINE_vertex *""'"); 
  }
  arg2 = (Dwg_MLINE_vertex *)(argp2);
  if (arg1) (arg1)->verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLINE_vertex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (Dwg_MLINE_vertex *) ((arg1)->verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINE_vertex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_mlinestyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MLINE_mlinestyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_mlinestyle_set" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MLINE_mlinestyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->mlinestyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MLINE_mlinestyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MLINE_mlinestyle_get" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  result = (BITCODE_H) ((arg1)->mlinestyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MLINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MLINE *)calloc(1, sizeof(struct _dwg_entity_MLINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MLINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MLINE *arg1 = (struct _dwg_entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MLINE" "', argument " "1"" of type '" "struct _dwg_entity_MLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_MLINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MLINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MLINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MLINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_model_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_model_space_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_model_space_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_CONTROL_model_space_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->model_space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_model_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_model_space_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (BITCODE_H) ((arg1)->model_space);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_paper_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_CONTROL_paper_space_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_paper_space_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_CONTROL_paper_space_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->paper_space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_CONTROL_paper_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_CONTROL_paper_space_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  result = (BITCODE_H) ((arg1)->paper_space);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCK_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCK_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCK_CONTROL *)calloc(1, sizeof(struct _dwg_object_BLOCK_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCK_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_CONTROL *arg1 = (struct _dwg_object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCK_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCK_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCK_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCK_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_flag_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_flag_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_used_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_used_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER___iterator_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER___iterator_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER___iterator_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER___iterator_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->__iterator = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER___iterator_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER___iterator_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->__iterator);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_anonymous_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_anonymous_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_anonymous_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_anonymous_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->anonymous = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_anonymous_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_anonymous_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->anonymous);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_hasattrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_hasattrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_hasattrs_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_hasattrs_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->hasattrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_hasattrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_hasattrs_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->hasattrs);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_blkisxref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_blkisxref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_blkisxref_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_blkisxref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->blkisxref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_blkisxref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_blkisxref_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->blkisxref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xrefoverlaid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_xrefoverlaid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xrefoverlaid_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_xrefoverlaid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->xrefoverlaid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xrefoverlaid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xrefoverlaid_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->xrefoverlaid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_loaded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_xref_loaded_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_loaded_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_xref_loaded_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->xref_loaded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_loaded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_loaded_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->xref_loaded);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_num_owned_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_num_owned_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_base_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_base_pt_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_base_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_pname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_xref_pname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_pname_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_xref_pname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->xref_pname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->xref_pname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->xref_pname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_xref_pname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_xref_pname_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_TV) ((arg1)->xref_pname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_num_inserts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_num_inserts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_num_inserts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_num_inserts_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_inserts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_num_inserts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_num_inserts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_inserts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_preview_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_preview_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_preview_size_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_preview_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->preview_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_preview_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_preview_size_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->preview_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_preview_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_preview_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_preview_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_preview_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->preview = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_preview_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_preview_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_TF) ((arg1)->preview);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_insert_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_insert_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_insert_units_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_insert_units_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->insert_units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_insert_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_insert_units_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->insert_units);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_explodable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_explodable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_explodable_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_explodable_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->explodable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_explodable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_explodable_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->explodable);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_scaling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_block_scaling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_scaling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_block_scaling_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->block_scaling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_scaling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_scaling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RC) ((arg1)->block_scaling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_block_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_entity_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_block_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_entity_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->block_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_first_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_first_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_first_entity_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_first_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_first_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_first_entity_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->first_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_last_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_last_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_last_entity_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_last_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_last_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_last_entity_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->last_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_entities_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_entities_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_entities_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_entities_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entities = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_entities_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_entities_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H *) ((arg1)->entities);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_endblk_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_endblk_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_endblk_entity_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_endblk_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->endblk_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_endblk_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_endblk_entity_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->endblk_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_inserts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_inserts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_inserts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_inserts_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->inserts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_inserts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_inserts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H *) ((arg1)->inserts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_layout_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_layout_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_layout_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCK_HEADER_layout_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->layout = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_layout_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_layout_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->layout);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_flag2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_flag2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_flag2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_flag2_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flag2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_flag2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_flag2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RS) ((arg1)->flag2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_unknown_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_unknown_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_unknown_r11_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_unknown_r11_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_unknown_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_unknown_r11_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_r11);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_offset_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCK_HEADER_block_offset_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_offset_r11_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCK_HEADER_block_offset_r11_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->block_offset_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCK_HEADER_block_offset_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCK_HEADER_block_offset_r11_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  result = (BITCODE_RL) ((arg1)->block_offset_r11);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCK_HEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCK_HEADER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCK_HEADER *)calloc(1, sizeof(struct _dwg_object_BLOCK_HEADER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_HEADER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCK_HEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCK_HEADER *arg1 = (struct _dwg_object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCK_HEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCK_HEADER" "', argument " "1"" of type '" "struct _dwg_object_BLOCK_HEADER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCK_HEADER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCK_HEADER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCK_HEADER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCK_HEADER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LAYER_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LAYER_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LAYER_CONTROL *)calloc(1, sizeof(struct _dwg_object_LAYER_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LAYER_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_CONTROL *arg1 = (struct _dwg_object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LAYER_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_LAYER_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LAYER_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LAYER_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LAYER_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_flag_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_flag_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_name_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_name_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_used_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_used_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_xref_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_xref_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_flag0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_flag0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_flag0_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_flag0_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_flag0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_flag0_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag0);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_frozen_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_frozen_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_frozen_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_frozen_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->frozen = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_frozen_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_frozen_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->frozen);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_off_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_off_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_off_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_off_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->off = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_off_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_off_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->off);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_frozen_in_new_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_frozen_in_new_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_frozen_in_new_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_frozen_in_new_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->frozen_in_new = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_frozen_in_new_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_frozen_in_new_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->frozen_in_new);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_locked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_locked_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_locked_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_locked_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->locked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_locked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_locked_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->locked);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_plotflag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_plotflag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_plotflag_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_plotflag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->plotflag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_plotflag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_plotflag_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_B) ((arg1)->plotflag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_linewt_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_RC) ((arg1)->linewt);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_color_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_color_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_plotstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_plotstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_plotstyle_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_plotstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->plotstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_plotstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_plotstyle_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_H) ((arg1)->plotstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_material_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_material_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->material = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_material_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_H) ((arg1)->material);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_H) ((arg1)->ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  result = (BITCODE_H) ((arg1)->visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LAYER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LAYER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LAYER *)calloc(1, sizeof(struct _dwg_object_LAYER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LAYER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER *arg1 = (struct _dwg_object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LAYER" "', argument " "1"" of type '" "struct _dwg_object_LAYER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LAYER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LAYER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LAYER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_STYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_STYLE_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_STYLE_CONTROL *)calloc(1, sizeof(struct _dwg_object_STYLE_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_STYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE_CONTROL *arg1 = (struct _dwg_object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_STYLE_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_STYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_STYLE_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_STYLE_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_STYLE_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_flag_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_flag_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_name_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_name_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_used_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_used_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_xref_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_xref_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_shape_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_is_shape_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_shape_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_is_shape_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_shape = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_shape_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_shape_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_shape);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_vertical_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_is_vertical_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_vertical_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_is_vertical_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_vertical = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_is_vertical_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_is_vertical_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_vertical);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_text_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_text_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_text_size_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_text_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_text_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_text_size_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_width_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_width_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_width_factor_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_width_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_width_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_width_factor_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->width_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_oblique_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_oblique_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_oblique_angle_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_oblique_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->oblique_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_oblique_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_oblique_angle_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->oblique_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_generation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_generation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_generation_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_generation_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->generation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_generation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_generation_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->generation);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_last_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_last_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_last_height_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_STYLE_last_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->last_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_last_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_last_height_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->last_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_font_file_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_font_file_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_font_file_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_font_file_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->font_file);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->font_file = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->font_file = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_font_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_font_file_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->font_file);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_bigfont_file_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_STYLE_bigfont_file_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_bigfont_file_set" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_STYLE_bigfont_file_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->bigfont_file);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->bigfont_file = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->bigfont_file = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_STYLE_bigfont_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_STYLE_bigfont_file_get" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->bigfont_file);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_STYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_STYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_STYLE *)calloc(1, sizeof(struct _dwg_object_STYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_STYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_STYLE *arg1 = (struct _dwg_object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_STYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_STYLE" "', argument " "1"" of type '" "struct _dwg_object_STYLE *""'"); 
  }
  arg1 = (struct _dwg_object_STYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_STYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_STYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_STYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_bylayer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_bylayer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_bylayer_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_CONTROL_bylayer_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->bylayer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_bylayer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_bylayer_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (BITCODE_H) ((arg1)->bylayer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_byblock_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_CONTROL_byblock_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_byblock_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_CONTROL_byblock_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->byblock = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_CONTROL_byblock_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_CONTROL_byblock_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  result = (BITCODE_H) ((arg1)->byblock);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LTYPE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LTYPE_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LTYPE_CONTROL *)calloc(1, sizeof(struct _dwg_object_LTYPE_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LTYPE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE_CONTROL *arg1 = (struct _dwg_object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LTYPE_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_LTYPE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LTYPE_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LTYPE_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LTYPE_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  struct _dwg_object_LTYPE *arg2 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_parent_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LTYPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LTYPE_dash_parent_set" "', argument " "2"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg2 = (struct _dwg_object_LTYPE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_LTYPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_parent_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (struct _dwg_object_LTYPE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_length_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_length_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_BD) ((arg1)->length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_complex_shapecode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_complex_shapecode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_complex_shapecode_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_complex_shapecode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->complex_shapecode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_complex_shapecode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_complex_shapecode_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_BS) ((arg1)->complex_shapecode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_style_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LTYPE_dash_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_style_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_x_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_x_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_x_offset_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_x_offset_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->x_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_x_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_x_offset_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_RD) ((arg1)->x_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_y_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_y_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_y_offset_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_y_offset_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->y_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_y_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_y_offset_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_RD) ((arg1)->y_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_scale_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_scale_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_rotation_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_rotation_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_shape_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_shape_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_shape_flag_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LTYPE_dash_shape_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shape_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_shape_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_shape_flag_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_BS) ((arg1)->shape_flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LTYPE_dash_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_text_set" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LTYPE_dash_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LTYPE_dash_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LTYPE_dash_text_get" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LTYPE_dash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LTYPE_dash", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LTYPE_dash *)calloc(1, sizeof(struct _dwg_LTYPE_dash));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LTYPE_dash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LTYPE_dash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LTYPE_dash *arg1 = (struct _dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LTYPE_dash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LTYPE_dash" "', argument " "1"" of type '" "struct _dwg_LTYPE_dash *""'"); 
  }
  arg1 = (struct _dwg_LTYPE_dash *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LTYPE_dash_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LTYPE_dash, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LTYPE_dash_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_flag_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_flag_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_name_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_name_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_used_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_used_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_xref_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_xref_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_description_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_description_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_pattern_len_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_pattern_len_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_pattern_len_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_pattern_len_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->pattern_len = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_pattern_len_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_pattern_len_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_BD) ((arg1)->pattern_len);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_alignment_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_alignment_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_alignment_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RC) ((arg1)->alignment);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_numdashes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_numdashes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_numdashes_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_numdashes_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->numdashes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_numdashes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_numdashes_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RC) ((arg1)->numdashes);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_dashes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  Dwg_LTYPE_dash *arg2 = (Dwg_LTYPE_dash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_dashes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_dashes_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LTYPE_dash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_dashes_set" "', argument " "2"" of type '" "Dwg_LTYPE_dash *""'"); 
  }
  arg2 = (Dwg_LTYPE_dash *)(argp2);
  if (arg1) (arg1)->dashes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_dashes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LTYPE_dash *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_dashes_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (Dwg_LTYPE_dash *) ((arg1)->dashes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LTYPE_dash, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_dashes_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RD *arg2 = (BITCODE_RD *) (BITCODE_RD *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_dashes_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_dashes_r11_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_dashes_r11_set" "', argument " "2"" of type '" "BITCODE_RD [12]""'"); 
  } 
  arg2 = (BITCODE_RD *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(BITCODE_RD *)&arg1->dashes_r11[ii] = *((BITCODE_RD *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""dashes_r11""' of type '""BITCODE_RD [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_dashes_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_dashes_r11_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RD *)(BITCODE_RD *) ((arg1)->dashes_r11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_has_strings_area_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_has_strings_area_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_has_strings_area_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_has_strings_area_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_strings_area = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_has_strings_area_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_has_strings_area_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_strings_area);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_strings_area_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_strings_area_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_strings_area_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LTYPE_strings_area_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->strings_area = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_strings_area_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_strings_area_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_TF) ((arg1)->strings_area);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_unknown_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LTYPE_unknown_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_unknown_r11_set" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LTYPE_unknown_r11_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LTYPE_unknown_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LTYPE_unknown_r11_get" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_r11);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LTYPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LTYPE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LTYPE *)calloc(1, sizeof(struct _dwg_object_LTYPE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LTYPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LTYPE *arg1 = (struct _dwg_object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LTYPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LTYPE" "', argument " "1"" of type '" "struct _dwg_object_LTYPE *""'"); 
  }
  arg1 = (struct _dwg_object_LTYPE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LTYPE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LTYPE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LTYPE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VIEW_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VIEW_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VIEW_CONTROL *)calloc(1, sizeof(struct _dwg_object_VIEW_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VIEW_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW_CONTROL *arg1 = (struct _dwg_object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VIEW_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_VIEW_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VIEW_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VIEW_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VIEW_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_flag_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_flag_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_name_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_name_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_used_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_used_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_xref_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_xref_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_VIEWSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWSIZE_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_VIEWSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->VIEWSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWSIZE_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->VIEWSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_view_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_view_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_view_width_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_view_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->view_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_view_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_view_width_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->view_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_aspect_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_aspect_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_aspect_ratio_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_aspect_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->aspect_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_aspect_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_aspect_ratio_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->aspect_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWCTR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_VIEWCTR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWCTR_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_VIEWCTR_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->VIEWCTR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWCTR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWCTR_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->VIEWCTR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_view_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_view_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_view_target_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_view_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->view_target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_view_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_view_target_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->view_target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_VIEWDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWDIR_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_VIEWDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->VIEWDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWDIR_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->VIEWDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_lens_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_lens_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_lens_length_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_lens_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lens_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_lens_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_lens_length_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->lens_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_front_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_front_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_front_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_front_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->front_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_front_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_front_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->front_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_back_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_back_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_back_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_back_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->back_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_back_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_back_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->back_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_4BITS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_VIEWMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWMODE_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_VIEWMODE_set" "', argument " "2"" of type '" "BITCODE_4BITS""'");
  } 
  arg2 = (BITCODE_4BITS)(val2);
  if (arg1) (arg1)->VIEWMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_VIEWMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_4BITS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_VIEWMODE_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_4BITS) ((arg1)->VIEWMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_render_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_render_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_render_mode_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_render_mode_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->render_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_render_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_render_mode_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RC) ((arg1)->render_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_use_default_lights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_use_default_lights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_use_default_lights_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_use_default_lights_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_default_lights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_use_default_lights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_use_default_lights_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->use_default_lights);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_default_lightning_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_default_lightning_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_default_lightning_type_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_default_lightning_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->default_lightning_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_default_lightning_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_default_lightning_type_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RC) ((arg1)->default_lightning_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_brightness_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_brightness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_brightness_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->brightness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_contrast_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_contrast_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_contrast_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->contrast);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ambient_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_ambient_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ambient_color_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_ambient_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->ambient_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ambient_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ambient_color_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->ambient_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_pspace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_is_pspace_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_pspace_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_is_pspace_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_pspace = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_pspace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_pspace_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->is_pspace);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_associated_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_associated_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_associated_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_associated_ucs_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->associated_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_associated_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_associated_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->associated_ucs);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsorg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_ucsorg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsorg_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_ucsorg_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsorg = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsorg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsorg_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsorg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsxdir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_ucsxdir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsxdir_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_ucsxdir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsxdir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsxdir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsxdir_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsxdir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsydir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_ucsydir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsydir_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_ucsydir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsydir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucsydir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucsydir_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsydir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucs_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_ucs_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucs_elevation_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_ucs_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ucs_elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_ucs_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_ucs_elevation_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BD) ((arg1)->ucs_elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_camera_plottable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_is_camera_plottable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_camera_plottable_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_is_camera_plottable_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_camera_plottable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_is_camera_plottable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_is_camera_plottable_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_B) ((arg1)->is_camera_plottable);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_background_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_background_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_background_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_background_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->background = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_background_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_background_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->background);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_sun_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_sun_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_sun_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_sun_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_sun_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_sun_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->sun);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_base_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_base_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_base_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_base_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->base_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_base_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_base_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->base_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_named_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_named_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_named_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_named_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->named_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_named_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_named_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->named_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_livesection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_livesection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_livesection_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VIEW_livesection_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->livesection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_livesection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_livesection_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_H) ((arg1)->livesection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_flag_3d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_flag_3d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_flag_3d_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_flag_3d_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flag_3d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_flag_3d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_flag_3d_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RS) ((arg1)->flag_3d);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_unknown_r2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_unknown_r2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_unknown_r2_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_unknown_r2_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_r2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_unknown_r2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_unknown_r2_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_r2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_unknown_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VIEW_unknown_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_unknown_r11_set" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VIEW_unknown_r11_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VIEW_unknown_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VIEW_unknown_r11_get" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_r11);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VIEW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VIEW", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VIEW *)calloc(1, sizeof(struct _dwg_object_VIEW));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VIEW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VIEW *arg1 = (struct _dwg_object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VIEW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VIEW" "', argument " "1"" of type '" "struct _dwg_object_VIEW *""'"); 
  }
  arg1 = (struct _dwg_object_VIEW *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VIEW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VIEW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VIEW_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_UCS_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_UCS_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_UCS_CONTROL *)calloc(1, sizeof(struct _dwg_object_UCS_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_UCS_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS_CONTROL *arg1 = (struct _dwg_object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_UCS_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_UCS_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_UCS_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_UCS_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_UCS_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_UCS_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  struct _dwg_object_UCS *arg2 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_UCS_orthopts_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_parent_set" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_UCS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_UCS_orthopts_parent_set" "', argument " "2"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg2 = (struct _dwg_object_UCS *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_UCS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_parent_get" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  result = (struct _dwg_object_UCS *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_UCS_orthopts_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_type_set" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_UCS_orthopts_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_type_get" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_UCS_orthopts_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_pt_set" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_UCS_orthopts_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_UCS_orthopts_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_UCS_orthopts_pt_get" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_UCS_orthopts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_UCS_orthopts", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_UCS_orthopts *)calloc(1, sizeof(struct _dwg_UCS_orthopts));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_UCS_orthopts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_UCS_orthopts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_UCS_orthopts *arg1 = (struct _dwg_UCS_orthopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_UCS_orthopts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_UCS_orthopts" "', argument " "1"" of type '" "struct _dwg_UCS_orthopts *""'"); 
  }
  arg1 = (struct _dwg_UCS_orthopts *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_UCS_orthopts_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_UCS_orthopts, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_UCS_orthopts_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_flag_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_flag_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_name_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_name_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_used_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_used_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_xref_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_xref_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsorg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_ucsorg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsorg_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_ucsorg_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsorg = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsorg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsorg_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsorg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsxdir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_ucsxdir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsxdir_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_ucsxdir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsxdir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsxdir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsxdir_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsxdir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsydir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_ucsydir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsydir_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_ucsydir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsydir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucsydir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucsydir_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsydir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucs_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_ucs_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucs_elevation_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_ucs_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ucs_elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_ucs_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_ucs_elevation_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_BD) ((arg1)->ucs_elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_base_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_base_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_base_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_base_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->base_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_base_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_base_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_H) ((arg1)->base_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_named_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_named_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_named_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_named_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->named_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_named_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_named_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_H) ((arg1)->named_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_num_orthopts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_num_orthopts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_num_orthopts_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_UCS_num_orthopts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_orthopts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_num_orthopts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_num_orthopts_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_orthopts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_orthopts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  Dwg_UCS_orthopts *arg2 = (Dwg_UCS_orthopts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UCS_orthopts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_orthopts_set" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_UCS_orthopts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UCS_orthopts_set" "', argument " "2"" of type '" "Dwg_UCS_orthopts *""'"); 
  }
  arg2 = (Dwg_UCS_orthopts *)(argp2);
  if (arg1) (arg1)->orthopts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UCS_orthopts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_UCS_orthopts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UCS_orthopts_get" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  result = (Dwg_UCS_orthopts *) ((arg1)->orthopts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_UCS_orthopts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_UCS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_UCS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_UCS *)calloc(1, sizeof(struct _dwg_object_UCS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_UCS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UCS *arg1 = (struct _dwg_object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UCS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_UCS" "', argument " "1"" of type '" "struct _dwg_object_UCS *""'"); 
  }
  arg1 = (struct _dwg_object_UCS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_UCS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_UCS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_UCS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VPORT_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VPORT_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VPORT_CONTROL *)calloc(1, sizeof(struct _dwg_object_VPORT_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VPORT_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT_CONTROL *arg1 = (struct _dwg_object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VPORT_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_VPORT_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VPORT_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VPORT_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VPORT_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_flag_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_flag_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_name_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_name_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_used_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_used_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_xref_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_xref_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWSIZE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_VIEWSIZE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWSIZE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_VIEWSIZE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->VIEWSIZE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWSIZE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWSIZE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->VIEWSIZE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_view_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_width_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_view_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->view_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_width_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->view_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_aspect_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_aspect_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_aspect_ratio_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_aspect_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->aspect_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_aspect_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_aspect_ratio_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->aspect_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWCTR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_VIEWCTR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWCTR_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_VIEWCTR_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->VIEWCTR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWCTR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWCTR_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->VIEWCTR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_view_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_target_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_view_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->view_target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_target_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->view_target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_VIEWDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWDIR_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_VIEWDIR_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->VIEWDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWDIR_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->VIEWDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_twist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_view_twist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_twist_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_view_twist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->view_twist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_view_twist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_view_twist_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->view_twist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_lens_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_lens_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_lens_length_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_lens_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lens_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_lens_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_lens_length_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->lens_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_front_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_front_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_front_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_front_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->front_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_front_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_front_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->front_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_back_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_back_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_back_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_back_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->back_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_back_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_back_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->back_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_4BITS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_VIEWMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWMODE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_VIEWMODE_set" "', argument " "2"" of type '" "BITCODE_4BITS""'");
  } 
  arg2 = (BITCODE_4BITS)(val2);
  if (arg1) (arg1)->VIEWMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_VIEWMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_4BITS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_VIEWMODE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_4BITS) ((arg1)->VIEWMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_render_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_render_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_render_mode_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_render_mode_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->render_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_render_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_render_mode_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->render_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_use_default_lights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_use_default_lights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_use_default_lights_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_use_default_lights_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_default_lights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_use_default_lights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_use_default_lights_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->use_default_lights);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_default_lightning_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_default_lightning_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_default_lightning_type_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_default_lightning_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->default_lightning_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_default_lightning_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_default_lightning_type_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->default_lightning_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_brightness_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_brightness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_brightness_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->brightness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_contrast_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_contrast_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_contrast_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->contrast);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ambient_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ambient_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ambient_color_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_ambient_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->ambient_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ambient_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ambient_color_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->ambient_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_lower_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_lower_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_lower_left_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_lower_left_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->lower_left = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_lower_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_lower_left_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->lower_left);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_upper_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_upper_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_upper_right_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_upper_right_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->upper_right = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_upper_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_upper_right_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->upper_right);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSFOLLOW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_UCSFOLLOW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSFOLLOW_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_UCSFOLLOW_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->UCSFOLLOW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSFOLLOW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSFOLLOW_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->UCSFOLLOW);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_circle_zoom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_circle_zoom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_circle_zoom_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_circle_zoom_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->circle_zoom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_circle_zoom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_circle_zoom_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->circle_zoom);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_FASTZOOM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_FASTZOOM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_FASTZOOM_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_FASTZOOM_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->FASTZOOM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_FASTZOOM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_FASTZOOM_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->FASTZOOM);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSICON_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_UCSICON_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSICON_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_UCSICON_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->UCSICON = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSICON_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSICON_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_RC) ((arg1)->UCSICON);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_GRIDMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_GRIDMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_GRIDMODE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_GRIDMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->GRIDMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_GRIDMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_GRIDMODE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->GRIDMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_GRIDUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_GRIDUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_GRIDUNIT_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_GRIDUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->GRIDUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_GRIDUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_GRIDUNIT_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->GRIDUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPMODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPMODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPMODE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_SNAPMODE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->SNAPMODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPMODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPMODE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->SNAPMODE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPSTYLE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_SNAPSTYLE_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->SNAPSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPSTYLE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->SNAPSTYLE);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPISOPAIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPISOPAIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPISOPAIR_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_SNAPISOPAIR_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->SNAPISOPAIR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPISOPAIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPISOPAIR_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->SNAPISOPAIR);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPANG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPANG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPANG_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_SNAPANG_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->SNAPANG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPANG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPANG_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->SNAPANG);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPBASE_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_SNAPBASE_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPBASE_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_SNAPUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPUNIT_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_SNAPUNIT_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->SNAPUNIT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_SNAPUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_SNAPUNIT_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->SNAPUNIT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucs_at_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ucs_at_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucs_at_origin_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_ucs_at_origin_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ucs_at_origin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucs_at_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucs_at_origin_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->ucs_at_origin);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSVP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_UCSVP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSVP_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_UCSVP_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->UCSVP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSVP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSVP_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_B) ((arg1)->UCSVP);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsorg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ucsorg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsorg_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_ucsorg_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsorg = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsorg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsorg_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsorg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsxdir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ucsxdir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsxdir_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_ucsxdir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsxdir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsxdir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsxdir_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsxdir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsydir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ucsydir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsydir_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_ucsydir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucsydir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucsydir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucsydir_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucsydir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucs_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_ucs_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucs_elevation_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_ucs_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ucs_elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_ucs_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_ucs_elevation_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BD) ((arg1)->ucs_elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_grid_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_grid_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_grid_flags_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_grid_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->grid_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_grid_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_grid_flags_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->grid_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_grid_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_grid_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_grid_major_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VPORT_grid_major_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->grid_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_grid_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_grid_major_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_BS) ((arg1)->grid_major);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_background_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_background_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_background_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_background_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->background = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_background_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_background_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->background);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_sun_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_sun_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_sun_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_sun_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_sun_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_sun_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->sun);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_named_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_named_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_named_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_named_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->named_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_named_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_named_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->named_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_base_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VPORT_base_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_base_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VPORT_base_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->base_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VPORT_base_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VPORT_base_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  result = (BITCODE_H) ((arg1)->base_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VPORT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VPORT *)calloc(1, sizeof(struct _dwg_object_VPORT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VPORT *arg1 = (struct _dwg_object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VPORT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VPORT" "', argument " "1"" of type '" "struct _dwg_object_VPORT *""'"); 
  }
  arg1 = (struct _dwg_object_VPORT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VPORT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VPORT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VPORT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_APPID_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_APPID_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_APPID_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_APPID_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_APPID_CONTROL *)calloc(1, sizeof(struct _dwg_object_APPID_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_APPID_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID_CONTROL *arg1 = (struct _dwg_object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_APPID_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_APPID_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_APPID_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_APPID_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_APPID_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_APPID_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_parent_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_APPID_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_parent_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_flag_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_flag_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_name_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_APPID_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_name_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_used_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_used_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_xref_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_APPID_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_xref_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_APPID_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_unknown_set" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_APPID_unknown_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_APPID_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_APPID_unknown_get" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_APPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_APPID", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_APPID *)calloc(1, sizeof(struct _dwg_object_APPID));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_APPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_APPID *arg1 = (struct _dwg_object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_APPID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_APPID" "', argument " "1"" of type '" "struct _dwg_object_APPID *""'"); 
  }
  arg1 = (struct _dwg_object_APPID *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_APPID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_APPID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_APPID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->num_morehandles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (BITCODE_RC) ((arg1)->num_morehandles);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_morehandles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_CONTROL_morehandles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_morehandles_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_morehandles_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->morehandles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_CONTROL_morehandles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_CONTROL_morehandles_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->morehandles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DIMSTYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DIMSTYLE_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DIMSTYLE_CONTROL *)calloc(1, sizeof(struct _dwg_object_DIMSTYLE_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DIMSTYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE_CONTROL *arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DIMSTYLE_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DIMSTYLE_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DIMSTYLE_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_flag_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_flag_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_name_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_name_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_used_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_used_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_xref_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_xref_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTOL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOL_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTOL_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOL_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOL);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLIM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLIM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLIM_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMLIM_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMLIM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLIM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLIM_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMLIM);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTIH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTIH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTIH_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTIH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTIH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTIH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTIH_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTIH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTOH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOH_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTOH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOH_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSE1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSE1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSE1_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSE1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSE1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSE1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSE1_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSE1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSE2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSE2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSE2_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSE2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSE2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSE2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSE2_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSE2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMALT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMALT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOFL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTOFL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOFL_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTOFL_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTOFL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOFL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOFL_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTOFL);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSAH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSAH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSAH_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSAH_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSAH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSAH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSAH_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSAH);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTIX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTIX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTIX_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTIX_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTIX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTIX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTIX_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTIX);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSOXD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSOXD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSOXD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSOXD_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSOXD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSOXD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSOXD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSOXD);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMZIN_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMZIN_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSD1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSD1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSD1_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSD1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSD1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSD1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSD1_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSD1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSD2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSD2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSD2_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSD2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMSD2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSD2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSD2_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMSD2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOLJ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTOLJ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOLJ_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTOLJ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTOLJ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTOLJ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTOLJ_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTOLJ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMJUST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMJUST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMJUST_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMJUST_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMJUST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMJUST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMJUST_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMJUST);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMFIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFIT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMFIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMFIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFIT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMFIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMUPT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMUPT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMUPT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMUPT_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMUPT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMUPT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMUPT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMUPT);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTZIN_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTZIN_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTZ_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTZ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTZ_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTZ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTTZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTTZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTZ_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTZ_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTTZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTTZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTZ_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTTZ);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTAD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTAD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTAD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTAD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTAD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTAD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTAD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTAD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMUNIT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMUNIT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMAUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAUNIT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMAUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMAUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAUNIT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMAUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMDEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDEC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMDEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMDEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDEC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMDEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTDEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTDEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTDEC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTDEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTDEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTDEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTDEC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTDEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTU_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTU_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTU_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTU_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTU);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTTD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTTD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTD_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMALTTD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTTD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTTD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMALTTD);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMSCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSCALE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMSCALE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMSCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMSCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMSCALE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMSCALE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMASZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMASZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMASZ_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMASZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMASZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMASZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMASZ_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMASZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMEXO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMEXO_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMEXO_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMEXO_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMEXO = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMEXO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMEXO_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMEXO);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDLI_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMDLI_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDLI_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMDLI_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMDLI = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDLI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDLI_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMDLI);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMEXE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMEXE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMEXE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMEXE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMEXE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMEXE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMEXE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMEXE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMRND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMRND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMRND_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMRND_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMRND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMRND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMRND_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMRND);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMDLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDLE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMDLE_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMDLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDLE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMDLE);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTP_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTP_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTM_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTM_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTM_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTM);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFXL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMFXL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFXL_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMFXL_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMFXL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFXL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFXL_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMFXL);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMJOGANG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMJOGANG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMJOGANG_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMJOGANG_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMJOGANG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMJOGANG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMJOGANG_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMJOGANG);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFILL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTFILL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILL_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILL_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTFILL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFILL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILL_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTFILL);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFILLCLR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTFILLCLR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILLCLR_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILLCLR_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMTFILLCLR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFILLCLR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFILLCLR_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMTFILLCLR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAZIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMAZIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAZIN_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMAZIN_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMAZIN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAZIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAZIN_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMAZIN);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMARCSYM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMARCSYM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMARCSYM_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMARCSYM_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMARCSYM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMARCSYM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMARCSYM_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMARCSYM);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTXT_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTXT);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCEN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCEN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCEN_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMCEN_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMCEN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCEN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCEN_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMCEN);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTSZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTSZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTSZ_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTSZ_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTSZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTSZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTSZ_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTSZ);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTF_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTF_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLFAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLFAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLFAC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMLFAC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMLFAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLFAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLFAC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMLFAC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTVP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTVP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTVP_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTVP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTVP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTVP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTVP_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTVP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTFAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFAC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTFAC_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMTFAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTFAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTFAC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMTFAC);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMGAP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMGAP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMGAP_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMGAP_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMGAP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMGAP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMGAP_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMGAP);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMPOST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMPOST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMPOST_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMPOST_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMPOST);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMPOST = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMPOST = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMPOST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMPOST_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMPOST);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAPOST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMAPOST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAPOST_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMAPOST_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMAPOST);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMAPOST = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMAPOST = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMAPOST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMAPOST_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMAPOST);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_T_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_T_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK1_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK1_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_T_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK1_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK1_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK1_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK1_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_T_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK1_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK2_T_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK2_T_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_T_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_T_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMBLK2_T);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMBLK2_T = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMBLK2_T = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK2_T_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_T_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMBLK2_T);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTRND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTRND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTRND_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTRND_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTRND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTRND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTRND_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTRND);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRD_N_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRD_N_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_N_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_N_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRD_N = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRD_N_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_N_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRD_N);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRE_N_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRE_N_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_N_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_N_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRE_N = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRE_N_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_N_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRE_N);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRT_N_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRT_N_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_N_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_N_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->DIMCLRT_N = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRT_N_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_N_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_RS) ((arg1)->DIMCLRT_N);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRD = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMCLRT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->DIMCLRT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMCLRT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMCLRT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->DIMCLRT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMADEC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMADEC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMADEC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMADEC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMADEC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMADEC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMADEC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMADEC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFRAC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMFRAC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFRAC_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMFRAC_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMFRAC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFRAC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFRAC_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMFRAC);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLUNIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLUNIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLUNIT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMLUNIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMLUNIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLUNIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLUNIT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMLUNIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDSEP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMDSEP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDSEP_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMDSEP_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMDSEP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMDSEP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMDSEP_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMDSEP);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTMOVE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTMOVE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTMOVE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTMOVE_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMTMOVE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTMOVE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTMOVE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMTMOVE);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMATFIT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMATFIT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMATFIT_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMATFIT_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->DIMATFIT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMATFIT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMATFIT_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->DIMATFIT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFXLON_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMFXLON_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFXLON_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMFXLON_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMFXLON = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMFXLON_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMFXLON_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMFXLON);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->DIMTXTDIRECTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->DIMTXTDIRECTION);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTMZF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTMZF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZF_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMALTMZF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTMZF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZF_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMALTMZF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTMZS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMALTMZS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZS_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMALTMZS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMALTMZS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMALTMZS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMALTMZS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMALTMZS_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMALTMZS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMMZF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMMZF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMMZF_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMMZF_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->DIMMZF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMMZF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMMZF_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->DIMMZF);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMMZS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMMZS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMMZS_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMMZS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->DIMMZS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->DIMMZS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->DIMMZS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMMZS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMMZS_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->DIMMZS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLWD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLWD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLWD_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMLWD_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->DIMLWD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLWD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLWD_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BSd) ((arg1)->DIMLWD);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLWE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLWE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLWE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_DIMLWE_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->DIMLWE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLWE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLWE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_BSd) ((arg1)->DIMLWE);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_flag0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_flag0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_flag0_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMSTYLE_flag0_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flag0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_flag0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_flag0_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->flag0);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXSTY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMTXSTY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXSTY_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMTXSTY_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMTXSTY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMTXSTY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMTXSTY_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMTXSTY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLDRBLK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLDRBLK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLDRBLK_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMLDRBLK_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLDRBLK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLDRBLK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLDRBLK_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLDRBLK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK1_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMBLK2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMBLK2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMBLK2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMBLK2_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMBLK2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTYPE_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMLTYPE_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTYPE_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTYPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTEX1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLTEX1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX1_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTEX1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTEX1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX1_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTEX1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTEX2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMSTYLE_DIMLTEX2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX2_set" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->DIMLTEX2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMSTYLE_DIMLTEX2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMSTYLE_DIMLTEX2_get" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->DIMLTEX2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DIMSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DIMSTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DIMSTYLE *)calloc(1, sizeof(struct _dwg_object_DIMSTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DIMSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMSTYLE *arg1 = (struct _dwg_object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DIMSTYLE" "', argument " "1"" of type '" "struct _dwg_object_DIMSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DIMSTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DIMSTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DIMSTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DIMSTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_CONTROL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_CONTROL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_CONTROL_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_CONTROL_num_entries_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_CONTROL_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_entries_set" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_CONTROL_entries_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_entries_get" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  result = (BITCODE_H *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_CONTROL_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_CONTROL_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_CONTROL_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_CONTROL_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VX_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VX_CONTROL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VX_CONTROL *)calloc(1, sizeof(struct _dwg_object_VX_CONTROL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_CONTROL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VX_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_CONTROL *arg1 = (struct _dwg_object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VX_CONTROL" "', argument " "1"" of type '" "struct _dwg_object_VX_CONTROL *""'"); 
  }
  arg1 = (struct _dwg_object_VX_CONTROL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VX_CONTROL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VX_CONTROL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VX_CONTROL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_TABLE_RECORD_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_flag_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_flag_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_name_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_TABLE_RECORD_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_name_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_used_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_used_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->used = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_used_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_RSd) ((arg1)->used);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_xref_resolved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_xref_resolved);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xref_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xref_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_xref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_xref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_xref_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_TABLE_RECORD_xref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_xref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_xref_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_H) ((arg1)->xref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_is_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_on_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_on_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_is_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_is_on_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_B) ((arg1)->is_on);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_viewport_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_viewport_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_viewport_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_TABLE_RECORD_viewport_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->viewport = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_viewport_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_viewport_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_H) ((arg1)->viewport);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_prev_entry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_prev_entry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_prev_entry_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VX_TABLE_RECORD_prev_entry_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->prev_entry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_prev_entry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_prev_entry_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_H) ((arg1)->prev_entry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->vport_entity_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_vport_entity_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_RS) ((arg1)->vport_entity_address);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->r11_viewport_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_RSd) ((arg1)->r11_viewport_index);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  BITCODE_RSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set" "', argument " "2"" of type '" "BITCODE_RSd""'");
  } 
  arg2 = (BITCODE_RSd)(val2);
  if (arg1) (arg1)->r11_prev_entry_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_get" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  result = (BITCODE_RSd) ((arg1)->r11_prev_entry_index);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VX_TABLE_RECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VX_TABLE_RECORD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VX_TABLE_RECORD *)calloc(1, sizeof(struct _dwg_object_VX_TABLE_RECORD));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VX_TABLE_RECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VX_TABLE_RECORD *arg1 = (struct _dwg_object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VX_TABLE_RECORD" "', argument " "1"" of type '" "struct _dwg_object_VX_TABLE_RECORD *""'"); 
  }
  arg1 = (struct _dwg_object_VX_TABLE_RECORD *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VX_TABLE_RECORD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VX_TABLE_RECORD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GROUP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_name_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GROUP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_name_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_unnamed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_unnamed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_unnamed_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUP_unnamed_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unnamed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_unnamed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_unnamed_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (BITCODE_BS) ((arg1)->unnamed);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_selectable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_selectable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_selectable_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUP_selectable_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->selectable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_selectable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_selectable_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (BITCODE_BS) ((arg1)->selectable);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_num_groups_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_num_groups_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_num_groups_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUP_num_groups_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_groups = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_num_groups_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_num_groups_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_groups);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_groups_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUP_groups_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_groups_set" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GROUP_groups_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->groups = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUP_groups_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUP_groups_get" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  result = (BITCODE_H *) ((arg1)->groups);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_GROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_GROUP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_GROUP *)calloc(1, sizeof(struct _dwg_object_GROUP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_GROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUP *arg1 = (struct _dwg_object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_GROUP" "', argument " "1"" of type '" "struct _dwg_object_GROUP *""'"); 
  }
  arg1 = (struct _dwg_object_GROUP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_GROUP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_GROUP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_GROUP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  struct _dwg_object_MLINESTYLE *arg2 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINESTYLE_line_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_parent_set" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MLINESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINESTYLE_line_parent_set" "', argument " "2"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg2 = (struct _dwg_object_MLINESTYLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_MLINESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_parent_get" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  result = (struct _dwg_object_MLINESTYLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINESTYLE_line_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_offset_set" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLINESTYLE_line_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_offset_get" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  result = (BITCODE_BD) ((arg1)->offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLINESTYLE_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_color_set" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLINESTYLE_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_color_get" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLINESTYLE_line_lt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_MLINESTYLE_line_lt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLINESTYLE_line_lt_get" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  result = (_dwg_MLINESTYLE_line_lt *)& ((arg1)->lt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINESTYLE_line_lt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLINESTYLE_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLINESTYLE_line", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLINESTYLE_line *)calloc(1, sizeof(struct _dwg_MLINESTYLE_line));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINESTYLE_line, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLINESTYLE_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLINESTYLE_line *arg1 = (struct _dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLINESTYLE_line" "', argument " "1"" of type '" "struct _dwg_MLINESTYLE_line *""'"); 
  }
  arg1 = (struct _dwg_MLINESTYLE_line *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLINESTYLE_line_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLINESTYLE_line, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLINESTYLE_line_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_MLINESTYLE_line_lt_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *arg1 = (_dwg_MLINESTYLE_line_lt *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_MLINESTYLE_line_lt_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line_lt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_MLINESTYLE_line_lt_index_set" "', argument " "1"" of type '" "_dwg_MLINESTYLE_line_lt *""'"); 
  }
  arg1 = (_dwg_MLINESTYLE_line_lt *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_MLINESTYLE_line_lt_index_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_MLINESTYLE_line_lt_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *arg1 = (_dwg_MLINESTYLE_line_lt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line_lt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_MLINESTYLE_line_lt_index_get" "', argument " "1"" of type '" "_dwg_MLINESTYLE_line_lt *""'"); 
  }
  arg1 = (_dwg_MLINESTYLE_line_lt *)(argp1);
  result = (BITCODE_BSd) ((arg1)->index);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_MLINESTYLE_line_lt_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *arg1 = (_dwg_MLINESTYLE_line_lt *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_MLINESTYLE_line_lt_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line_lt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_MLINESTYLE_line_lt_ltype_set" "', argument " "1"" of type '" "_dwg_MLINESTYLE_line_lt *""'"); 
  }
  arg1 = (_dwg_MLINESTYLE_line_lt *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_MLINESTYLE_line_lt_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_MLINESTYLE_line_lt_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *arg1 = (_dwg_MLINESTYLE_line_lt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line_lt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_MLINESTYLE_line_lt_ltype_get" "', argument " "1"" of type '" "_dwg_MLINESTYLE_line_lt *""'"); 
  }
  arg1 = (_dwg_MLINESTYLE_line_lt *)(argp1);
  result = (BITCODE_H) ((arg1)->ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_MLINESTYLE_line_lt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_MLINESTYLE_line_lt", 0, 0, 0)) SWIG_fail;
  result = (_dwg_MLINESTYLE_line_lt *)calloc(1, sizeof(_dwg_MLINESTYLE_line_lt));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINESTYLE_line_lt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_MLINESTYLE_line_lt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_MLINESTYLE_line_lt *arg1 = (_dwg_MLINESTYLE_line_lt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLINESTYLE_line_lt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_MLINESTYLE_line_lt" "', argument " "1"" of type '" "_dwg_MLINESTYLE_line_lt *""'"); 
  }
  arg1 = (_dwg_MLINESTYLE_line_lt *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_MLINESTYLE_line_lt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLINESTYLE_line_lt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_MLINESTYLE_line_lt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLINESTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_name_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLINESTYLE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_name_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_description_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLINESTYLE_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_description_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_flag_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLINESTYLE_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_flag_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_fill_color_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLINESTYLE_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_fill_color_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_start_angle_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLINESTYLE_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_start_angle_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_end_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_end_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_end_angle_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLINESTYLE_end_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_end_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_end_angle_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_num_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_num_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_num_lines_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLINESTYLE_num_lines_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->num_lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_num_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_num_lines_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->num_lines);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  Dwg_MLINESTYLE_line *arg2 = (Dwg_MLINESTYLE_line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLINESTYLE_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_lines_set" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLINESTYLE_line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLINESTYLE_lines_set" "', argument " "2"" of type '" "Dwg_MLINESTYLE_line *""'"); 
  }
  arg2 = (Dwg_MLINESTYLE_line *)(argp2);
  if (arg1) (arg1)->lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLINESTYLE_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLINESTYLE_line *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLINESTYLE_lines_get" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  result = (Dwg_MLINESTYLE_line *) ((arg1)->lines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLINESTYLE_line, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MLINESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MLINESTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MLINESTYLE *)calloc(1, sizeof(struct _dwg_object_MLINESTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLINESTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MLINESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLINESTYLE *arg1 = (struct _dwg_object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLINESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MLINESTYLE" "', argument " "1"" of type '" "struct _dwg_object_MLINESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLINESTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MLINESTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MLINESTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MLINESTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLE2FRAME_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_type_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLE2FRAME_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_type_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLE2FRAME_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_BS) ((arg1)->mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_lock_aspect_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_lock_aspect_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_lock_aspect_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLE2FRAME_lock_aspect_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->lock_aspect = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_lock_aspect_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_lock_aspect_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_RC) ((arg1)->lock_aspect);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLE2FRAME_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_data_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLE2FRAME_data_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_data_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_TF) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_oleversion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_oleversion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_oleversion_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_OLE2FRAME_oleversion_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->oleversion = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_oleversion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_oleversion_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_BS) ((arg1)->oleversion);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_oleclient_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_oleclient_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_oleclient_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLE2FRAME_oleclient_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->oleclient = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_oleclient_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_oleclient_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_TF) ((arg1)->oleclient);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_pt1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_pt1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_pt1_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLE2FRAME_pt1_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_pt1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_pt1_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_pt2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_OLE2FRAME_pt2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_pt2_set" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_OLE2FRAME_pt2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_OLE2FRAME_pt2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_OLE2FRAME_pt2_get" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_OLE2FRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_OLE2FRAME", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_OLE2FRAME *)calloc(1, sizeof(struct _dwg_entity_OLE2FRAME));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLE2FRAME, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_OLE2FRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_OLE2FRAME *arg1 = (struct _dwg_entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_OLE2FRAME, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_OLE2FRAME" "', argument " "1"" of type '" "struct _dwg_entity_OLE2FRAME *""'"); 
  }
  arg1 = (struct _dwg_entity_OLE2FRAME *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_OLE2FRAME_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_OLE2FRAME, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_OLE2FRAME_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DUMMY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DUMMY *arg1 = (struct _dwg_object_DUMMY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DUMMY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DUMMY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DUMMY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DUMMY *""'"); 
  }
  arg1 = (struct _dwg_object_DUMMY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DUMMY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DUMMY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DUMMY *arg1 = (struct _dwg_object_DUMMY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DUMMY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DUMMY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DUMMY *""'"); 
  }
  arg1 = (struct _dwg_object_DUMMY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DUMMY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DUMMY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DUMMY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DUMMY *)calloc(1, sizeof(struct _dwg_object_DUMMY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DUMMY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DUMMY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DUMMY *arg1 = (struct _dwg_object_DUMMY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DUMMY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DUMMY" "', argument " "1"" of type '" "struct _dwg_object_DUMMY *""'"); 
  }
  arg1 = (struct _dwg_object_DUMMY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DUMMY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DUMMY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DUMMY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LONG_TRANSACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LONG_TRANSACTION *arg1 = (struct _dwg_object_LONG_TRANSACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LONG_TRANSACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LONG_TRANSACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LONG_TRANSACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LONG_TRANSACTION *""'"); 
  }
  arg1 = (struct _dwg_object_LONG_TRANSACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LONG_TRANSACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LONG_TRANSACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LONG_TRANSACTION *arg1 = (struct _dwg_object_LONG_TRANSACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LONG_TRANSACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LONG_TRANSACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LONG_TRANSACTION *""'"); 
  }
  arg1 = (struct _dwg_object_LONG_TRANSACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LONG_TRANSACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LONG_TRANSACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LONG_TRANSACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LONG_TRANSACTION *)calloc(1, sizeof(struct _dwg_object_LONG_TRANSACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LONG_TRANSACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LONG_TRANSACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LONG_TRANSACTION *arg1 = (struct _dwg_object_LONG_TRANSACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LONG_TRANSACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LONG_TRANSACTION" "', argument " "1"" of type '" "struct _dwg_object_LONG_TRANSACTION *""'"); 
  }
  arg1 = (struct _dwg_object_LONG_TRANSACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LONG_TRANSACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LONG_TRANSACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LONG_TRANSACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LWPOLYLINE_width_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *arg1 = (struct _dwg_LWPOLYLINE_width *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LWPOLYLINE_width_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LWPOLYLINE_width_start_set" "', argument " "1"" of type '" "struct _dwg_LWPOLYLINE_width *""'"); 
  }
  arg1 = (struct _dwg_LWPOLYLINE_width *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LWPOLYLINE_width_start_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LWPOLYLINE_width_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *arg1 = (struct _dwg_LWPOLYLINE_width *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LWPOLYLINE_width_start_get" "', argument " "1"" of type '" "struct _dwg_LWPOLYLINE_width *""'"); 
  }
  arg1 = (struct _dwg_LWPOLYLINE_width *)(argp1);
  result = (BITCODE_BD) ((arg1)->start);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LWPOLYLINE_width_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *arg1 = (struct _dwg_LWPOLYLINE_width *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LWPOLYLINE_width_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LWPOLYLINE_width_end_set" "', argument " "1"" of type '" "struct _dwg_LWPOLYLINE_width *""'"); 
  }
  arg1 = (struct _dwg_LWPOLYLINE_width *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LWPOLYLINE_width_end_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LWPOLYLINE_width_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *arg1 = (struct _dwg_LWPOLYLINE_width *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LWPOLYLINE_width_end_get" "', argument " "1"" of type '" "struct _dwg_LWPOLYLINE_width *""'"); 
  }
  arg1 = (struct _dwg_LWPOLYLINE_width *)(argp1);
  result = (BITCODE_BD) ((arg1)->end);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LWPOLYLINE_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LWPOLYLINE_width", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LWPOLYLINE_width *)calloc(1, sizeof(struct _dwg_LWPOLYLINE_width));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LWPOLYLINE_width, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LWPOLYLINE_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LWPOLYLINE_width *arg1 = (struct _dwg_LWPOLYLINE_width *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LWPOLYLINE_width, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LWPOLYLINE_width" "', argument " "1"" of type '" "struct _dwg_LWPOLYLINE_width *""'"); 
  }
  arg1 = (struct _dwg_LWPOLYLINE_width *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LWPOLYLINE_width_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LWPOLYLINE_width, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LWPOLYLINE_width_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  struct _dwg_entity_PROXY_ENTITY *arg2 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_parent_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PROXY_LWPOLYLINE_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg2 = (struct _dwg_entity_PROXY_ENTITY *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_PROXY_ENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_parent_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (struct _dwg_entity_PROXY_ENTITY *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_data_size_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_data_size_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_RL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_flags_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_flags_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_const_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_const_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_const_width_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_const_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->const_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_const_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_const_width_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->const_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_elevation_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_elevation_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_thickness_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_thickness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_thickness_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PROXY_LWPOLYLINE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_points_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_points_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_points_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PROXY_LWPOLYLINE_points_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_points_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_bulges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_num_bulges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_bulges_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_num_bulges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_bulges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_bulges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_bulges_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_bulges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_bulges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_bulges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_bulges_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PROXY_LWPOLYLINE_bulges_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->bulges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_bulges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_bulges_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->bulges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_widths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_num_widths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_widths_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_num_widths_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_widths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_num_widths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_num_widths_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_widths);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_widths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  Dwg_LWPOLYLINE_width *arg2 = (Dwg_LWPOLYLINE_width *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_widths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_widths_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LWPOLYLINE_width, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PROXY_LWPOLYLINE_widths_set" "', argument " "2"" of type '" "Dwg_LWPOLYLINE_width *""'"); 
  }
  arg2 = (Dwg_LWPOLYLINE_width *)(argp2);
  if (arg1) (arg1)->widths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_widths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LWPOLYLINE_width *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_widths_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (Dwg_LWPOLYLINE_width *) ((arg1)->widths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PROXY_LWPOLYLINE_unknown_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_3_set" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_3_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PROXY_LWPOLYLINE_unknown_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PROXY_LWPOLYLINE_unknown_3_get" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_3);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_PROXY_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_PROXY_LWPOLYLINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_PROXY_LWPOLYLINE *)calloc(1, sizeof(struct _dwg_PROXY_LWPOLYLINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_PROXY_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PROXY_LWPOLYLINE *arg1 = (struct _dwg_PROXY_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_PROXY_LWPOLYLINE" "', argument " "1"" of type '" "struct _dwg_PROXY_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_PROXY_LWPOLYLINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_PROXY_LWPOLYLINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_PROXY_LWPOLYLINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_PROXY_LWPOLYLINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PROXY_ENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_proxy_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_id_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->proxy_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_id_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->proxy_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_class_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_class_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_class_id_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_class_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_class_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_class_id_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_dwg_versions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_dwg_versions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_versions_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_versions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dwg_versions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_dwg_versions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_versions_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->dwg_versions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_maint_version_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_maint_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_maint_version_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_from_dxf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_from_dxf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_from_dxf_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_from_dxf_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->from_dxf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_from_dxf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_from_dxf_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_B) ((arg1)->from_dxf);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_proxy_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->proxy_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->proxy_data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_proxy_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->proxy_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_proxy_data_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_RC *) ((arg1)->proxy_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_numbits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_data_numbits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_numbits_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_data_numbits_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_numbits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_numbits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_numbits_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_numbits);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PROXY_ENTITY_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_data_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_RC *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_num_objids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_num_objids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_num_objids_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PROXY_ENTITY_num_objids_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_objids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_num_objids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_num_objids_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_objids);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_objids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PROXY_ENTITY_objids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_objids_set" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PROXY_ENTITY_objids_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->objids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PROXY_ENTITY_objids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PROXY_ENTITY_objids_get" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  result = (BITCODE_H *) ((arg1)->objids);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_PROXY_ENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_PROXY_ENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_PROXY_ENTITY *)calloc(1, sizeof(struct _dwg_entity_PROXY_ENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PROXY_ENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_PROXY_ENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PROXY_ENTITY *arg1 = (struct _dwg_entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_PROXY_ENTITY" "', argument " "1"" of type '" "struct _dwg_entity_PROXY_ENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_PROXY_ENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_PROXY_ENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_PROXY_ENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_PROXY_ENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PROXY_OBJECT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_proxy_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_proxy_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_proxy_id_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_proxy_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->proxy_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_proxy_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_proxy_id_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->proxy_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_class_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_class_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_class_id_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_class_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_class_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_class_id_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_dwg_versions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_dwg_versions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_versions_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_versions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dwg_versions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_dwg_versions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_versions_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->dwg_versions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_maint_version_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_maint_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_maint_version_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_from_dxf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_from_dxf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_from_dxf_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_from_dxf_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->from_dxf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_from_dxf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_from_dxf_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_B) ((arg1)->from_dxf);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_numbits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_data_numbits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_numbits_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_data_numbits_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_numbits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_numbits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_numbits_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_numbits);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_size_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_size_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PROXY_OBJECT_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_data_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_RC *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_num_objids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_num_objids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_num_objids_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PROXY_OBJECT_num_objids_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_objids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_num_objids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_num_objids_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_objids);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_objids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PROXY_OBJECT_objids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_objids_set" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PROXY_OBJECT_objids_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->objids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PROXY_OBJECT_objids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PROXY_OBJECT_objids_get" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  result = (BITCODE_H *) ((arg1)->objids);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_PROXY_OBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_PROXY_OBJECT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_PROXY_OBJECT *)calloc(1, sizeof(struct _dwg_object_PROXY_OBJECT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PROXY_OBJECT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_PROXY_OBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PROXY_OBJECT *arg1 = (struct _dwg_object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PROXY_OBJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_PROXY_OBJECT" "', argument " "1"" of type '" "struct _dwg_object_PROXY_OBJECT *""'"); 
  }
  arg1 = (struct _dwg_object_PROXY_OBJECT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_PROXY_OBJECT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_PROXY_OBJECT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_PROXY_OBJECT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  struct _dwg_entity_HATCH *arg2 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Color_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Color_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg2 = (struct _dwg_entity_HATCH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_HATCH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  result = (struct _dwg_entity_HATCH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_shift_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Color_shift_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_shift_value_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Color_shift_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->shift_value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_shift_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_shift_value_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  result = (BITCODE_BD) ((arg1)->shift_value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Color_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_color_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Color_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Color_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Color_color_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_Color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_Color", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_Color *)calloc(1, sizeof(struct _dwg_HATCH_Color));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Color, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_Color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Color *arg1 = (struct _dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Color, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_Color" "', argument " "1"" of type '" "struct _dwg_HATCH_Color *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Color *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_Color_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_Color, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_Color_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  struct _dwg_HATCH_PathSeg *arg2 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_ControlPoint_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_PathSeg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_ControlPoint_parent_set" "', argument " "2"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg2 = (struct _dwg_HATCH_PathSeg *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_HATCH_PathSeg *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  result = (struct _dwg_HATCH_PathSeg *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_ControlPoint_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_point_set" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_ControlPoint_point_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_point_get" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_ControlPoint_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_weight_set" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_ControlPoint_weight_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_ControlPoint_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_ControlPoint_weight_get" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  result = (BITCODE_BD) ((arg1)->weight);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_ControlPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_ControlPoint", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_ControlPoint *)calloc(1, sizeof(struct _dwg_HATCH_ControlPoint));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_ControlPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_ControlPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_ControlPoint *arg1 = (struct _dwg_HATCH_ControlPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_ControlPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_ControlPoint" "', argument " "1"" of type '" "struct _dwg_HATCH_ControlPoint *""'"); 
  }
  arg1 = (struct _dwg_HATCH_ControlPoint *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_ControlPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_ControlPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_ControlPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  struct _dwg_HATCH_Path *arg2 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_parent_set" "', argument " "2"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg2 = (struct _dwg_HATCH_Path *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_HATCH_Path *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (struct _dwg_HATCH_Path *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_curve_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_curve_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_curve_type_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_curve_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->curve_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_curve_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_curve_type_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_RC) ((arg1)->curve_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_first_endpoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_first_endpoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_first_endpoint_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_first_endpoint_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->first_endpoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_first_endpoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_first_endpoint_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->first_endpoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_second_endpoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_second_endpoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_second_endpoint_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_second_endpoint_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->second_endpoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_second_endpoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_second_endpoint_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->second_endpoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_center_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_center_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_center_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_radius_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_radius_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_start_angle_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_start_angle_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_end_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_end_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_end_angle_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_end_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_end_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_end_angle_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_ccw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_is_ccw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_ccw_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_is_ccw_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_ccw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_ccw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_ccw_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_B) ((arg1)->is_ccw);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_endpoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_endpoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_endpoint_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_endpoint_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->endpoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_endpoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_endpoint_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->endpoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_minor_major_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_minor_major_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_minor_major_ratio_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_minor_major_ratio_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->minor_major_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_minor_major_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_minor_major_ratio_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BD) ((arg1)->minor_major_ratio);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_degree_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_degree_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_degree_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_degree_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->degree = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_degree_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_degree_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BL) ((arg1)->degree);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_rational_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_is_rational_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_rational_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_is_rational_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_rational = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_rational_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_rational_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_B) ((arg1)->is_rational);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_periodic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_is_periodic_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_periodic_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_is_periodic_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_periodic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_is_periodic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_is_periodic_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_B) ((arg1)->is_periodic);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_num_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_knots_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_num_knots_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_knots_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_knots);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_control_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_num_control_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_control_points_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_num_control_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_control_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_control_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_control_points_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_control_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_knots_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_knots_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_knots_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BD *) ((arg1)->knots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_control_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  Dwg_HATCH_ControlPoint *arg2 = (Dwg_HATCH_ControlPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_control_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_control_points_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_ControlPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_control_points_set" "', argument " "2"" of type '" "Dwg_HATCH_ControlPoint *""'"); 
  }
  arg2 = (Dwg_HATCH_ControlPoint *)(argp2);
  if (arg1) (arg1)->control_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_control_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_ControlPoint *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_control_points_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (Dwg_HATCH_ControlPoint *) ((arg1)->control_points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_ControlPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_fitpts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_num_fitpts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_fitpts_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PathSeg_num_fitpts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_fitpts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_num_fitpts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_num_fitpts_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_fitpts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_fitpts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_fitpts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_fitpts_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_fitpts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->fitpts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_fitpts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_fitpts_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->fitpts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_start_tangent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_start_tangent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_start_tangent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_start_tangent_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->start_tangent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_start_tangent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_start_tangent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->start_tangent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_end_tangent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PathSeg_end_tangent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_end_tangent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PathSeg_end_tangent_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->end_tangent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PathSeg_end_tangent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PathSeg_end_tangent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->end_tangent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_PathSeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_PathSeg", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_PathSeg *)calloc(1, sizeof(struct _dwg_HATCH_PathSeg));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_PathSeg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_PathSeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PathSeg *arg1 = (struct _dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PathSeg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_PathSeg" "', argument " "1"" of type '" "struct _dwg_HATCH_PathSeg *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PathSeg *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_PathSeg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_PathSeg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_PathSeg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  struct _dwg_HATCH_Path *arg2 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PolylinePath_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PolylinePath_parent_set" "', argument " "2"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg2 = (struct _dwg_HATCH_Path *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_HATCH_Path *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  result = (struct _dwg_HATCH_Path *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PolylinePath_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_point_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_PolylinePath_point_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_point_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_bulge_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_PolylinePath_bulge_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_bulge_set" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_PolylinePath_bulge_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bulge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_PolylinePath_bulge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_PolylinePath_bulge_get" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  result = (BITCODE_BD) ((arg1)->bulge);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_PolylinePath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_PolylinePath", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_PolylinePath *)calloc(1, sizeof(struct _dwg_HATCH_PolylinePath));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_PolylinePath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_PolylinePath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_PolylinePath *arg1 = (struct _dwg_HATCH_PolylinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_PolylinePath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_PolylinePath" "', argument " "1"" of type '" "struct _dwg_HATCH_PolylinePath *""'"); 
  }
  arg1 = (struct _dwg_HATCH_PolylinePath *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_PolylinePath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_PolylinePath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_PolylinePath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  struct _dwg_entity_HATCH *arg2 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Path_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg2 = (struct _dwg_entity_HATCH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_HATCH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (struct _dwg_entity_HATCH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_flag_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Path_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_flag_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_BL) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_num_segs_or_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_num_segs_or_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_num_segs_or_paths_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Path_num_segs_or_paths_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_segs_or_paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_num_segs_or_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_num_segs_or_paths_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_segs_or_paths);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_segs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  Dwg_HATCH_PathSeg *arg2 = (Dwg_HATCH_PathSeg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_segs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_segs_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_PathSeg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Path_segs_set" "', argument " "2"" of type '" "Dwg_HATCH_PathSeg *""'"); 
  }
  arg2 = (Dwg_HATCH_PathSeg *)(argp2);
  if (arg1) (arg1)->segs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_segs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_PathSeg *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_segs_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (Dwg_HATCH_PathSeg *) ((arg1)->segs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_PathSeg, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_bulges_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_bulges_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_bulges_present_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Path_bulges_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bulges_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_bulges_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_bulges_present_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_B) ((arg1)->bulges_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_closed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_closed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_closed_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Path_closed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->closed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_closed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_closed_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_B) ((arg1)->closed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_polyline_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  Dwg_HATCH_PolylinePath *arg2 = (Dwg_HATCH_PolylinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_polyline_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_polyline_paths_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_PolylinePath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Path_polyline_paths_set" "', argument " "2"" of type '" "Dwg_HATCH_PolylinePath *""'"); 
  }
  arg2 = (Dwg_HATCH_PolylinePath *)(argp2);
  if (arg1) (arg1)->polyline_paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_polyline_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_PolylinePath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_polyline_paths_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (Dwg_HATCH_PolylinePath *) ((arg1)->polyline_paths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_PolylinePath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_num_boundary_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_num_boundary_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_num_boundary_handles_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_Path_num_boundary_handles_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_boundary_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_num_boundary_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_num_boundary_handles_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_boundary_handles);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_boundary_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_Path_boundary_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_boundary_handles_set" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_Path_boundary_handles_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->boundary_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_Path_boundary_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_Path_boundary_handles_get" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  result = (BITCODE_H *) ((arg1)->boundary_handles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_Path(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_Path", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_Path *)calloc(1, sizeof(struct _dwg_HATCH_Path));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_Path(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_Path *arg1 = (struct _dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_Path" "', argument " "1"" of type '" "struct _dwg_HATCH_Path *""'"); 
  }
  arg1 = (struct _dwg_HATCH_Path *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_Path_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_Path, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_Path_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  struct _dwg_entity_HATCH *arg2 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_parent_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_DefLine_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg2 = (struct _dwg_entity_HATCH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_HATCH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_parent_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (struct _dwg_entity_HATCH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_angle_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_DefLine_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_angle_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_pt0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  BITCODE_2BD *arg2 = (BITCODE_2BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_pt0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_pt0_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_DefLine_pt0_set" "', argument " "2"" of type '" "BITCODE_2BD *""'"); 
  }
  arg2 = (BITCODE_2BD *)(argp2);
  if (arg1) (arg1)->pt0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_pt0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_pt0_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (BITCODE_2BD *)& ((arg1)->pt0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  BITCODE_2BD *arg2 = (BITCODE_2BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_offset_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_DefLine_offset_set" "', argument " "2"" of type '" "BITCODE_2BD *""'"); 
  }
  arg2 = (BITCODE_2BD *)(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_offset_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (BITCODE_2BD *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_num_dashes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_num_dashes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_num_dashes_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_HATCH_DefLine_num_dashes_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_dashes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_num_dashes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_num_dashes_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_dashes);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_dashes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_HATCH_DefLine_dashes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_dashes_set" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_HATCH_DefLine_dashes_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->dashes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_HATCH_DefLine_dashes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_HATCH_DefLine_dashes_get" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  result = (BITCODE_BD *) ((arg1)->dashes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_HATCH_DefLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_HATCH_DefLine", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_HATCH_DefLine *)calloc(1, sizeof(struct _dwg_HATCH_DefLine));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_DefLine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_HATCH_DefLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_HATCH_DefLine *arg1 = (struct _dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_HATCH_DefLine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_HATCH_DefLine" "', argument " "1"" of type '" "struct _dwg_HATCH_DefLine *""'"); 
  }
  arg1 = (struct _dwg_HATCH_DefLine *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_HATCH_DefLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_HATCH_DefLine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_HATCH_DefLine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_gradient_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_is_gradient_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_gradient_fill_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_is_gradient_fill_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->is_gradient_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_gradient_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_gradient_fill_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->is_gradient_fill);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_reserved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_reserved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_reserved_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_reserved_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->reserved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_reserved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_reserved_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->reserved);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_gradient_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_gradient_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_shift_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_gradient_shift_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_shift_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_gradient_shift_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_shift = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_shift_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_shift_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_shift);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_single_color_gradient_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_single_color_gradient_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_single_color_gradient_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_single_color_gradient_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->single_color_gradient = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_single_color_gradient_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_single_color_gradient_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->single_color_gradient);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_tint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_gradient_tint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_tint_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_gradient_tint_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_tint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_tint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_tint_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_tint);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_colors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_num_colors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_colors_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_num_colors_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_colors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_colors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_colors_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_colors);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_colors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  Dwg_HATCH_Color *arg2 = (Dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_colors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_colors_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Color, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_colors_set" "', argument " "2"" of type '" "Dwg_HATCH_Color *""'"); 
  }
  arg2 = (Dwg_HATCH_Color *)(argp2);
  if (arg1) (arg1)->colors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_colors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_Color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_colors_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (Dwg_HATCH_Color *) ((arg1)->colors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_gradient_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_name_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_gradient_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->gradient_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->gradient_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->gradient_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_gradient_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_gradient_name_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_TV) ((arg1)->gradient_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_name_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_name_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_solid_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_is_solid_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_solid_fill_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_is_solid_fill_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_solid_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_solid_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_solid_fill_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_B) ((arg1)->is_solid_fill);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_associative_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_is_associative_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_associative_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_is_associative_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_associative = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_is_associative_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_is_associative_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_B) ((arg1)->is_associative);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_num_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_paths_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_num_paths_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_paths_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_paths);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  Dwg_HATCH_Path *arg2 = (Dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_paths_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_paths_set" "', argument " "2"" of type '" "Dwg_HATCH_Path *""'"); 
  }
  arg2 = (Dwg_HATCH_Path *)(argp2);
  if (arg1) (arg1)->paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_Path *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_paths_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (Dwg_HATCH_Path *) ((arg1)->paths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_style_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_style_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BS) ((arg1)->style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_pattern_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_pattern_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_pattern_type_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_pattern_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->pattern_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_pattern_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_pattern_type_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BS) ((arg1)->pattern_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_scale_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_scale_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_scale_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_scale_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_scale_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_scale_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_double_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_double_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_double_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_double_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->double_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_double_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_double_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_B) ((arg1)->double_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_deflines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_num_deflines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_deflines_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_num_deflines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_deflines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_deflines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_deflines_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_deflines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_deflines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  Dwg_HATCH_DefLine *arg2 = (Dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_deflines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_deflines_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_DefLine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_deflines_set" "', argument " "2"" of type '" "Dwg_HATCH_DefLine *""'"); 
  }
  arg2 = (Dwg_HATCH_DefLine *)(argp2);
  if (arg1) (arg1)->deflines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_deflines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_DefLine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_deflines_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (Dwg_HATCH_DefLine *) ((arg1)->deflines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_has_derived_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_has_derived_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_has_derived_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_has_derived_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_derived = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_has_derived_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_has_derived_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_B) ((arg1)->has_derived);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_pixel_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_pixel_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_pixel_size_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_pixel_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->pixel_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_pixel_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_pixel_size_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BD) ((arg1)->pixel_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_seeds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_num_seeds_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_seeds_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HATCH_num_seeds_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_seeds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_num_seeds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_num_seeds_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_seeds);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_seeds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HATCH_seeds_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_seeds_set" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HATCH_seeds_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->seeds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HATCH_seeds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HATCH_seeds_get" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->seeds);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_HATCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_HATCH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_HATCH *)calloc(1, sizeof(struct _dwg_entity_HATCH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_HATCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HATCH *arg1 = (struct _dwg_entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_HATCH" "', argument " "1"" of type '" "struct _dwg_entity_HATCH *""'"); 
  }
  arg1 = (struct _dwg_entity_HATCH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_HATCH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_HATCH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_HATCH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_gradient_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_is_gradient_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_gradient_fill_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_is_gradient_fill_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->is_gradient_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_gradient_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_gradient_fill_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->is_gradient_fill);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_reserved_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_reserved_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_reserved_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_reserved_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->reserved = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_reserved_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_reserved_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->reserved);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_gradient_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_gradient_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_shift_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_gradient_shift_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_shift_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_gradient_shift_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_shift = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_shift_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_shift_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_shift);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_single_color_gradient_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_single_color_gradient_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_single_color_gradient_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_single_color_gradient_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->single_color_gradient = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_single_color_gradient_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_single_color_gradient_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->single_color_gradient);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_tint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_gradient_tint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_tint_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_gradient_tint_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gradient_tint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_tint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_tint_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->gradient_tint);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_colors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_num_colors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_colors_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_num_colors_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_colors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_colors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_colors_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_colors);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_colors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  Dwg_HATCH_Color *arg2 = (Dwg_HATCH_Color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_colors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_colors_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Color, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_colors_set" "', argument " "2"" of type '" "Dwg_HATCH_Color *""'"); 
  }
  arg2 = (Dwg_HATCH_Color *)(argp2);
  if (arg1) (arg1)->colors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_colors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_Color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_colors_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (Dwg_HATCH_Color *) ((arg1)->colors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_gradient_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_name_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_gradient_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->gradient_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->gradient_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->gradient_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_gradient_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_gradient_name_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_TV) ((arg1)->gradient_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_name_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_name_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_solid_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_is_solid_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_solid_fill_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_is_solid_fill_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_solid_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_solid_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_solid_fill_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_B) ((arg1)->is_solid_fill);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_associative_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_is_associative_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_associative_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_is_associative_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_associative = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_is_associative_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_is_associative_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_B) ((arg1)->is_associative);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_num_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_paths_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_num_paths_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_paths_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_paths);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_paths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  Dwg_HATCH_Path *arg2 = (Dwg_HATCH_Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_paths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_paths_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_paths_set" "', argument " "2"" of type '" "Dwg_HATCH_Path *""'"); 
  }
  arg2 = (Dwg_HATCH_Path *)(argp2);
  if (arg1) (arg1)->paths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_paths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_Path *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_paths_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (Dwg_HATCH_Path *) ((arg1)->paths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_style_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_style_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BS) ((arg1)->style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_pattern_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_pattern_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_pattern_type_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_pattern_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->pattern_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_pattern_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_pattern_type_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BS) ((arg1)->pattern_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_scale_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_scale_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_scale_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_scale_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_scale_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_scale_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_double_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_double_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_double_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_double_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->double_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_double_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_double_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_B) ((arg1)->double_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_deflines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_num_deflines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_deflines_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_num_deflines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_deflines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_deflines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_deflines_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_deflines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_deflines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  Dwg_HATCH_DefLine *arg2 = (Dwg_HATCH_DefLine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_deflines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_deflines_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_HATCH_DefLine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_deflines_set" "', argument " "2"" of type '" "Dwg_HATCH_DefLine *""'"); 
  }
  arg2 = (Dwg_HATCH_DefLine *)(argp2);
  if (arg1) (arg1)->deflines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_deflines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_HATCH_DefLine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_deflines_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (Dwg_HATCH_DefLine *) ((arg1)->deflines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_HATCH_DefLine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_hatch_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_hatch_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_hatch_color_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_hatch_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->hatch_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_hatch_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_hatch_color_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->hatch_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_x_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_x_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_x_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MPOLYGON_x_dir_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->x_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_x_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_x_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->x_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_boundary_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MPOLYGON_num_boundary_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_boundary_handles_set" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MPOLYGON_num_boundary_handles_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_boundary_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MPOLYGON_num_boundary_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MPOLYGON_num_boundary_handles_get" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_boundary_handles);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MPOLYGON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MPOLYGON", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MPOLYGON *)calloc(1, sizeof(struct _dwg_entity_MPOLYGON));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MPOLYGON, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MPOLYGON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MPOLYGON *arg1 = (struct _dwg_entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MPOLYGON, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MPOLYGON" "', argument " "1"" of type '" "struct _dwg_entity_MPOLYGON *""'"); 
  }
  arg1 = (struct _dwg_entity_MPOLYGON *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MPOLYGON_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MPOLYGON, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MPOLYGON_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_parent_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_XRECORD_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_parent_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_cloning_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_cloning_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_cloning_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_XRECORD_cloning_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->cloning = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_cloning_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_cloning_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (BITCODE_BS) ((arg1)->cloning);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_xdata_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_xdata_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_xdata_size_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_XRECORD_xdata_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->xdata_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_xdata_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_xdata_size_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (BITCODE_BL) ((arg1)->xdata_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_num_xdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_num_xdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_num_xdata_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_XRECORD_num_xdata_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_xdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_num_xdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_num_xdata_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_xdata);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_xdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  Dwg_Resbuf *arg2 = (Dwg_Resbuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_xdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_xdata_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_resbuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_XRECORD_xdata_set" "', argument " "2"" of type '" "Dwg_Resbuf *""'"); 
  }
  arg2 = (Dwg_Resbuf *)(argp2);
  if (arg1) (arg1)->xdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_xdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Resbuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_xdata_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (Dwg_Resbuf *) ((arg1)->xdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_resbuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_num_objid_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_num_objid_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_num_objid_handles_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_XRECORD_num_objid_handles_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_objid_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_num_objid_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_num_objid_handles_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_objid_handles);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_objid_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_XRECORD_objid_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_objid_handles_set" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_XRECORD_objid_handles_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->objid_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_XRECORD_objid_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_XRECORD_objid_handles_get" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  result = (BITCODE_H *) ((arg1)->objid_handles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_XRECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_XRECORD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_XRECORD *)calloc(1, sizeof(struct _dwg_object_XRECORD));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_XRECORD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_XRECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_XRECORD *arg1 = (struct _dwg_object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_XRECORD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_XRECORD" "', argument " "1"" of type '" "struct _dwg_object_XRECORD *""'"); 
  }
  arg1 = (struct _dwg_object_XRECORD *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_XRECORD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_XRECORD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_XRECORD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_PLACEHOLDER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLACEHOLDER *arg1 = (struct _dwg_object_PLACEHOLDER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLACEHOLDER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLACEHOLDER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLACEHOLDER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_PLACEHOLDER *""'"); 
  }
  arg1 = (struct _dwg_object_PLACEHOLDER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLACEHOLDER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLACEHOLDER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLACEHOLDER *arg1 = (struct _dwg_object_PLACEHOLDER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLACEHOLDER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLACEHOLDER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_PLACEHOLDER *""'"); 
  }
  arg1 = (struct _dwg_object_PLACEHOLDER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_PLACEHOLDER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLACEHOLDER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_PLACEHOLDER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_PLACEHOLDER *)calloc(1, sizeof(struct _dwg_object_PLACEHOLDER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLACEHOLDER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_PLACEHOLDER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLACEHOLDER *arg1 = (struct _dwg_object_PLACEHOLDER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLACEHOLDER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_PLACEHOLDER" "', argument " "1"" of type '" "struct _dwg_object_PLACEHOLDER *""'"); 
  }
  arg1 = (struct _dwg_object_PLACEHOLDER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_PLACEHOLDER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_PLACEHOLDER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_PLACEHOLDER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  struct _dwg_LEADER_Line *arg2 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Break_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_parent_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Break_parent_set" "', argument " "2"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg2 = (struct _dwg_LEADER_Line *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_LEADER_Line *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_parent_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  result = (struct _dwg_LEADER_Line *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Break_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_start_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Break_start_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->start = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_start_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->start);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Break_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_end_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Break_end_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->end = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Break_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Break_end_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->end);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LEADER_Break(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LEADER_Break", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LEADER_Break *)calloc(1, sizeof(struct _dwg_LEADER_Break));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Break, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LEADER_Break(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Break *arg1 = (struct _dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Break, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LEADER_Break" "', argument " "1"" of type '" "struct _dwg_LEADER_Break *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Break *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LEADER_Break_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LEADER_Break, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LEADER_Break_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  struct _dwg_LEADER_Node *arg2 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_parent_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_parent_set" "', argument " "2"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg2 = (struct _dwg_LEADER_Node *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_LEADER_Node *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_parent_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (struct _dwg_LEADER_Node *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_num_points_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_num_points_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_points_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_points_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_points_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_num_breaks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_num_breaks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_num_breaks_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_num_breaks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_breaks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_num_breaks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_num_breaks_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_breaks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_breaks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  Dwg_LEADER_Break *arg2 = (Dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_breaks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_breaks_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Break, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_breaks_set" "', argument " "2"" of type '" "Dwg_LEADER_Break *""'"); 
  }
  arg2 = (Dwg_LEADER_Break *)(argp2);
  if (arg1) (arg1)->breaks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_breaks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_Break *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_breaks_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (Dwg_LEADER_Break *) ((arg1)->breaks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_line_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_line_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_line_index_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_line_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->line_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_line_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_line_index_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BL) ((arg1)->line_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_type_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_type_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_color_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_color_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_ltype_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_ltype_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_H) ((arg1)->ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_linewt_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_linewt_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BLd) ((arg1)->linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_arrow_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_arrow_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_arrow_size_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_arrow_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_arrow_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_arrow_size_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_arrow_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_arrow_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_arrow_handle_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Line_arrow_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_arrow_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_arrow_handle_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Line_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_flags_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Line_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Line_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Line_flags_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LEADER_Line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LEADER_Line", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LEADER_Line *)calloc(1, sizeof(struct _dwg_LEADER_Line));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Line, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LEADER_Line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Line *arg1 = (struct _dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LEADER_Line" "', argument " "1"" of type '" "struct _dwg_LEADER_Line *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Line *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LEADER_Line_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LEADER_Line, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LEADER_Line_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  struct _dwg_entity_MULTILEADER *arg2 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_ArrowHead_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_parent_set" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_ArrowHead_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg2 = (struct _dwg_entity_MULTILEADER *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_parent_get" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  result = (struct _dwg_entity_MULTILEADER *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_ArrowHead_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_is_default_set" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_ArrowHead_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_is_default_get" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_arrowhead_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_ArrowHead_arrowhead_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_arrowhead_set" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_ArrowHead_arrowhead_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrowhead = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_ArrowHead_arrowhead_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_ArrowHead_arrowhead_get" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  result = (BITCODE_H) ((arg1)->arrowhead);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LEADER_ArrowHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LEADER_ArrowHead", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LEADER_ArrowHead *)calloc(1, sizeof(struct _dwg_LEADER_ArrowHead));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_ArrowHead, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LEADER_ArrowHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_ArrowHead *arg1 = (struct _dwg_LEADER_ArrowHead *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_ArrowHead, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LEADER_ArrowHead" "', argument " "1"" of type '" "struct _dwg_LEADER_ArrowHead *""'"); 
  }
  arg1 = (struct _dwg_LEADER_ArrowHead *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LEADER_ArrowHead_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LEADER_ArrowHead, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LEADER_ArrowHead_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  struct _dwg_entity_MULTILEADER *arg2 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_BlockLabel_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_parent_set" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_BlockLabel_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg2 = (struct _dwg_entity_MULTILEADER *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_parent_get" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  result = (struct _dwg_entity_MULTILEADER *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_attdef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_BlockLabel_attdef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_attdef_set" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_BlockLabel_attdef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->attdef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_attdef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_attdef_get" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  result = (BITCODE_H) ((arg1)->attdef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_label_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_BlockLabel_label_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_label_text_set" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_BlockLabel_label_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->label_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->label_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->label_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_label_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_label_text_get" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  result = (BITCODE_TV) ((arg1)->label_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_ui_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_BlockLabel_ui_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_ui_index_set" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_BlockLabel_ui_index_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->ui_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_ui_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_ui_index_get" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  result = (BITCODE_BS) ((arg1)->ui_index);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_BlockLabel_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_width_set" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_BlockLabel_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_BlockLabel_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_BlockLabel_width_get" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LEADER_BlockLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LEADER_BlockLabel", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LEADER_BlockLabel *)calloc(1, sizeof(struct _dwg_LEADER_BlockLabel));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_BlockLabel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LEADER_BlockLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_BlockLabel *arg1 = (struct _dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_BlockLabel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LEADER_BlockLabel" "', argument " "1"" of type '" "struct _dwg_LEADER_BlockLabel *""'"); 
  }
  arg1 = (struct _dwg_LEADER_BlockLabel *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LEADER_BlockLabel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LEADER_BlockLabel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LEADER_BlockLabel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  struct _dwg_entity_MULTILEADER *arg2 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_parent_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Node_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg2 = (struct _dwg_entity_MULTILEADER *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_parent_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (struct _dwg_entity_MULTILEADER *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_has_lastleaderlinepoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_has_lastleaderlinepoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_has_lastleaderlinepoint_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_has_lastleaderlinepoint_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_lastleaderlinepoint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_has_lastleaderlinepoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_has_lastleaderlinepoint_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_B) ((arg1)->has_lastleaderlinepoint);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_has_dogleg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_has_dogleg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_has_dogleg_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_has_dogleg_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_dogleg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_has_dogleg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_has_dogleg_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_B) ((arg1)->has_dogleg);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_lastleaderlinepoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_lastleaderlinepoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_lastleaderlinepoint_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Node_lastleaderlinepoint_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->lastleaderlinepoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_lastleaderlinepoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_lastleaderlinepoint_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->lastleaderlinepoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_dogleg_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_dogleg_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_dogleg_vector_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Node_dogleg_vector_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->dogleg_vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_dogleg_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_dogleg_vector_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->dogleg_vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_branch_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_branch_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_branch_index_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_branch_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->branch_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_branch_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_branch_index_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_BL) ((arg1)->branch_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_dogleg_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_dogleg_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_dogleg_length_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_dogleg_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->dogleg_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_dogleg_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_dogleg_length_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_BD) ((arg1)->dogleg_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_num_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_num_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_num_lines_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_num_lines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_num_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_num_lines_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_lines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_lines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  Dwg_LEADER_Line *arg2 = (Dwg_LEADER_Line *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_lines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_lines_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Line, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Node_lines_set" "', argument " "2"" of type '" "Dwg_LEADER_Line *""'"); 
  }
  arg2 = (Dwg_LEADER_Line *)(argp2);
  if (arg1) (arg1)->lines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_lines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_Line *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_lines_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (Dwg_LEADER_Line *) ((arg1)->lines);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Line, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_num_breaks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_num_breaks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_num_breaks_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_num_breaks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_breaks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_num_breaks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_num_breaks_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_breaks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_breaks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  Dwg_LEADER_Break *arg2 = (Dwg_LEADER_Break *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_breaks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_breaks_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Break, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LEADER_Node_breaks_set" "', argument " "2"" of type '" "Dwg_LEADER_Break *""'"); 
  }
  arg2 = (Dwg_LEADER_Break *)(argp2);
  if (arg1) (arg1)->breaks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_breaks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_Break *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_breaks_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (Dwg_LEADER_Break *) ((arg1)->breaks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Break, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_attach_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LEADER_Node_attach_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_attach_dir_set" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LEADER_Node_attach_dir_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LEADER_Node_attach_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LEADER_Node_attach_dir_get" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_dir);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LEADER_Node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LEADER_Node", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LEADER_Node *)calloc(1, sizeof(struct _dwg_LEADER_Node));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Node, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LEADER_Node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LEADER_Node *arg1 = (struct _dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LEADER_Node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LEADER_Node" "', argument " "1"" of type '" "struct _dwg_LEADER_Node *""'"); 
  }
  arg1 = (struct _dwg_LEADER_Node *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LEADER_Node_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LEADER_Node, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LEADER_Node_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_type_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_type_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_RC) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_normal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_normal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_normal_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_normal_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->normal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_normal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_normal_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->normal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_location_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_location_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_rotation_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_rotation_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_style_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_style_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_direction_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_direction_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_color_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_color_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_width_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_width_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_height_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_height_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_line_spacing_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_line_spacing_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_factor_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->line_spacing_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_line_spacing_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_factor_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->line_spacing_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_default_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_default_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_default_text_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_default_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->default_text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->default_text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->default_text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_default_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_default_text_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_TV) ((arg1)->default_text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_line_spacing_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_line_spacing_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_style_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_style_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->line_spacing_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_line_spacing_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_line_spacing_style_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BS) ((arg1)->line_spacing_style);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_alignment_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_alignment_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BS) ((arg1)->alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_flow_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_flow_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_flow_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_flow_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_flow_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_flow_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BS) ((arg1)->flow);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_bg_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_color_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_bg_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bg_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_color_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bg_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_bg_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_scale_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_bg_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bg_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_scale_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->bg_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_bg_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_transparency_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_bg_transparency_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_bg_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_bg_transparency_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_transparency);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_bg_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_is_bg_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_bg_fill_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_is_bg_fill_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_bg_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_bg_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_bg_fill_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->is_bg_fill);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_bg_mask_fill_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_is_bg_mask_fill_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_bg_mask_fill_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_is_bg_mask_fill_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_bg_mask_fill = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_bg_mask_fill_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_bg_mask_fill_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->is_bg_mask_fill);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_col_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_type_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_col_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->col_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_type_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BS) ((arg1)->col_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_height_auto_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_is_height_auto_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_height_auto_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_is_height_auto_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_height_auto = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_height_auto_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_height_auto_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->is_height_auto);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_col_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_width_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_col_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->col_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_width_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->col_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_gutter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_col_gutter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_gutter_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_col_gutter_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->col_gutter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_gutter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_gutter_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD) ((arg1)->col_gutter);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_col_flow_reversed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_is_col_flow_reversed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_col_flow_reversed_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_is_col_flow_reversed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_col_flow_reversed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_is_col_flow_reversed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_is_col_flow_reversed_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->is_col_flow_reversed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_num_col_sizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_num_col_sizes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_num_col_sizes_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_num_col_sizes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_col_sizes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_num_col_sizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_num_col_sizes_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_col_sizes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_sizes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_col_sizes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_sizes_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_MText_col_sizes_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->col_sizes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_col_sizes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_col_sizes_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_BD *) ((arg1)->col_sizes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_word_break_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_word_break_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_word_break_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_word_break_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->word_break = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_word_break_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_word_break_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->word_break);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_MText_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_unknown_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_MText_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_MText_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_MText_unknown_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLEADER_Content_MText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLEADER_Content_MText", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLEADER_Content_MText *)calloc(1, sizeof(struct _dwg_MLEADER_Content_MText));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content_MText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLEADER_Content_MText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_MText *arg1 = (struct _dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_MText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLEADER_Content_MText" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_MText *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_MText *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLEADER_Content_MText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLEADER_Content_MText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLEADER_Content_MText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_type_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_Block_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_type_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_RC) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_normal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_normal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_normal_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_normal_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->normal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_normal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_normal_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->normal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_location_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_location_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_rotation_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_Content_Block_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_rotation_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_block_table_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_block_table_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_block_table_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_block_table_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_table = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_block_table_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_block_table_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_H) ((arg1)->block_table);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_scale_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_scale_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_color_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_color_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_Block_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_transform_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_Block_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_Block_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_Block_transform_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLEADER_Content_Block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLEADER_Content_Block", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLEADER_Content_Block *)calloc(1, sizeof(struct _dwg_MLEADER_Content_Block));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content_Block, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLEADER_Content_Block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_Content_Block *arg1 = (struct _dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content_Block, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLEADER_Content_Block" "', argument " "1"" of type '" "struct _dwg_MLEADER_Content_Block *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_Content_Block *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLEADER_Content_Block_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLEADER_Content_Block, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLEADER_Content_Block_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_txt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *arg1 = (union _dwg_MLEADER_Content *) 0 ;
  Dwg_MLEADER_Content_MText *arg2 = (Dwg_MLEADER_Content_MText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_txt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_txt_set" "', argument " "1"" of type '" "union _dwg_MLEADER_Content *""'"); 
  }
  arg1 = (union _dwg_MLEADER_Content *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_txt_set" "', argument " "2"" of type '" "Dwg_MLEADER_Content_MText *""'"); 
  }
  arg2 = (Dwg_MLEADER_Content_MText *)(argp2);
  if (arg1) (arg1)->txt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_txt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *arg1 = (union _dwg_MLEADER_Content *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLEADER_Content_MText *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_txt_get" "', argument " "1"" of type '" "union _dwg_MLEADER_Content *""'"); 
  }
  arg1 = (union _dwg_MLEADER_Content *)(argp1);
  result = (Dwg_MLEADER_Content_MText *)& ((arg1)->txt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content_MText, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_blk_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *arg1 = (union _dwg_MLEADER_Content *) 0 ;
  Dwg_MLEADER_Content_Block *arg2 = (Dwg_MLEADER_Content_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_Content_blk_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_blk_set" "', argument " "1"" of type '" "union _dwg_MLEADER_Content *""'"); 
  }
  arg1 = (union _dwg_MLEADER_Content *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_Content_blk_set" "', argument " "2"" of type '" "Dwg_MLEADER_Content_Block *""'"); 
  }
  arg2 = (Dwg_MLEADER_Content_Block *)(argp2);
  if (arg1) (arg1)->blk = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_Content_blk_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *arg1 = (union _dwg_MLEADER_Content *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLEADER_Content_Block *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_Content_blk_get" "', argument " "1"" of type '" "union _dwg_MLEADER_Content *""'"); 
  }
  arg1 = (union _dwg_MLEADER_Content *)(argp1);
  result = (Dwg_MLEADER_Content_Block *)& ((arg1)->blk);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content_Block, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLEADER_Content(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLEADER_Content", 0, 0, 0)) SWIG_fail;
  result = (union _dwg_MLEADER_Content *)calloc(1, sizeof(union _dwg_MLEADER_Content));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLEADER_Content(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union _dwg_MLEADER_Content *arg1 = (union _dwg_MLEADER_Content *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_Content, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLEADER_Content" "', argument " "1"" of type '" "union _dwg_MLEADER_Content *""'"); 
  }
  arg1 = (union _dwg_MLEADER_Content *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLEADER_Content_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLEADER_Content, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLEADER_Content_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_num_leaders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_num_leaders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_num_leaders_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_num_leaders_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_leaders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_num_leaders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_num_leaders_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_leaders);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_leaders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  Dwg_LEADER_Node *arg2 = (Dwg_LEADER_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_leaders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_leaders_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_Node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_leaders_set" "', argument " "2"" of type '" "Dwg_LEADER_Node *""'"); 
  }
  arg2 = (Dwg_LEADER_Node *)(argp2);
  if (arg1) (arg1)->leaders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_leaders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_Node *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_leaders_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (Dwg_LEADER_Node *) ((arg1)->leaders);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_Node, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_attach_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_attach_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_attach_dir_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_attach_dir_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_attach_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_attach_dir_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_dir);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_content_base_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_content_base_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_content_base_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_content_base_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->content_base = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_content_base_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_content_base_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->content_base);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_height_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_height_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_arrow_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_arrow_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_arrow_size_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_arrow_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_arrow_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_arrow_size_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_landing_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_landing_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_landing_gap_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_landing_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->landing_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_landing_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_landing_gap_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BD) ((arg1)->landing_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_left_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_left_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_left = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_left_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_left);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_right_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_right_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_right = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_right_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_right);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_angletype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_angletype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_angletype_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_angletype_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_angletype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_angletype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_angletype_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_angletype);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_alignment_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_alignment_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_has_content_txt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_has_content_txt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_has_content_txt_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_has_content_txt_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_content_txt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_has_content_txt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_has_content_txt_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_B) ((arg1)->has_content_txt);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_has_content_blk_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_has_content_blk_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_has_content_blk_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_has_content_blk_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_content_blk = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_has_content_blk_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_has_content_blk_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_B) ((arg1)->has_content_blk);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_content_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  Dwg_MLEADER_Content *arg2 = (Dwg_MLEADER_Content *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_content_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_content_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_content_set" "', argument " "2"" of type '" "Dwg_MLEADER_Content *""'"); 
  }
  arg2 = (Dwg_MLEADER_Content *)(argp2);
  if (arg1) (arg1)->content = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_content_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLEADER_Content *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_content_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (Dwg_MLEADER_Content *)& ((arg1)->content);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_Content, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_base_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_base_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_base_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_dir_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_base_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_dir_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_vert_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_base_vert_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_vert_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MLEADER_AnnotContext_base_vert_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_vert = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_base_vert_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_base_vert_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_vert);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_is_normal_reversed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_is_normal_reversed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_is_normal_reversed_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_is_normal_reversed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_normal_reversed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_is_normal_reversed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_is_normal_reversed_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_B) ((arg1)->is_normal_reversed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_top_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_top_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_top = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_top_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_top);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MLEADER_AnnotContext_text_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_bottom_set" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MLEADER_AnnotContext_text_bottom_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_bottom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MLEADER_AnnotContext_text_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MLEADER_AnnotContext_text_bottom_get" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_bottom);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MLEADER_AnnotContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MLEADER_AnnotContext", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MLEADER_AnnotContext *)calloc(1, sizeof(struct _dwg_MLEADER_AnnotContext));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_AnnotContext, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MLEADER_AnnotContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MLEADER_AnnotContext *arg1 = (struct _dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MLEADER_AnnotContext, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MLEADER_AnnotContext" "', argument " "1"" of type '" "struct _dwg_MLEADER_AnnotContext *""'"); 
  }
  arg1 = (struct _dwg_MLEADER_AnnotContext *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MLEADER_AnnotContext_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MLEADER_AnnotContext, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MLEADER_AnnotContext_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_ctx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  Dwg_MLEADER_AnnotContext *arg2 = (Dwg_MLEADER_AnnotContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_ctx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_ctx_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_ctx_set" "', argument " "2"" of type '" "Dwg_MLEADER_AnnotContext *""'"); 
  }
  arg2 = (Dwg_MLEADER_AnnotContext *)(argp2);
  if (arg1) (arg1)->ctx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_ctx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MLEADER_AnnotContext *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_ctx_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (Dwg_MLEADER_AnnotContext *)& ((arg1)->ctx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MLEADER_AnnotContext, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_mleaderstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_mleaderstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_mleaderstyle_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_mleaderstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->mleaderstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_mleaderstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_mleaderstyle_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->mleaderstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_type_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_type_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_color_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_color_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_line_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_ltype_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_line_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->line_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_ltype_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->line_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_line_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_line_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->line_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_line_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_line_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BLd) ((arg1)->line_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_landing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_has_landing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_landing_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_has_landing_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_landing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_landing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_landing_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->has_landing);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_dogleg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_has_dogleg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_dogleg_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_has_dogleg_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_dogleg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_dogleg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_dogleg_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->has_dogleg);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_landing_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_landing_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_landing_dist_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_landing_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->landing_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_landing_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_landing_dist_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->landing_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrow_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_arrow_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrow_handle_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_arrow_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrow_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrow_handle_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrow_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_arrow_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrow_size_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_arrow_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrow_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrow_size_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_style_content_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_style_content_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_style_content_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_style_content_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->style_content = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_style_content_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_style_content_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->style_content);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_style_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_style_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_left_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_text_left_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_left = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_left_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_left);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_right_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_text_right_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_right = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_right_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_right);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_angletype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_angletype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_angletype_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_text_angletype_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_angletype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_angletype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_angletype_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_angletype);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_text_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_text_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_color_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_text_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->text_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_text_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_text_color_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->text_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_text_frame_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_has_text_frame_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_text_frame_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_has_text_frame_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_text_frame = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_has_text_frame_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_has_text_frame_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->has_text_frame);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_block_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_style_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_block_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_style_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_H) ((arg1)->block_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_block_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_color_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_block_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->block_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_color_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->block_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_block_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->block_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->block_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_block_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_block_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->block_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_block_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_block_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->block_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_style_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_style_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_style_attachment_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_style_attachment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->style_attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_style_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_style_attachment_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->style_attachment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_annotative_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_is_annotative_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_annotative_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_is_annotative_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_annotative = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_annotative_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_annotative_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_annotative);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_num_arrowheads_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_num_arrowheads_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_num_arrowheads_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_num_arrowheads_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_arrowheads = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_num_arrowheads_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_num_arrowheads_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_arrowheads);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrowheads_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  Dwg_LEADER_ArrowHead *arg2 = (Dwg_LEADER_ArrowHead *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_arrowheads_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrowheads_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_ArrowHead, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_arrowheads_set" "', argument " "2"" of type '" "Dwg_LEADER_ArrowHead *""'"); 
  }
  arg2 = (Dwg_LEADER_ArrowHead *)(argp2);
  if (arg1) (arg1)->arrowheads = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_arrowheads_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_ArrowHead *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_arrowheads_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (Dwg_LEADER_ArrowHead *) ((arg1)->arrowheads);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_ArrowHead, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_num_blocklabels_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_num_blocklabels_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_num_blocklabels_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_num_blocklabels_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocklabels = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_num_blocklabels_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_num_blocklabels_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocklabels);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_blocklabels_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  Dwg_LEADER_BlockLabel *arg2 = (Dwg_LEADER_BlockLabel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_blocklabels_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_blocklabels_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LEADER_BlockLabel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MULTILEADER_blocklabels_set" "', argument " "2"" of type '" "Dwg_LEADER_BlockLabel *""'"); 
  }
  arg2 = (Dwg_LEADER_BlockLabel *)(argp2);
  if (arg1) (arg1)->blocklabels = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_blocklabels_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LEADER_BlockLabel *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_blocklabels_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (Dwg_LEADER_BlockLabel *) ((arg1)->blocklabels);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LEADER_BlockLabel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_neg_textdir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_is_neg_textdir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_neg_textdir_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_is_neg_textdir_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_neg_textdir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_neg_textdir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_neg_textdir_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_neg_textdir);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_ipe_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_ipe_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_ipe_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_ipe_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->ipe_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_ipe_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_ipe_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->ipe_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_justification_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_justification_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_justification_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_justification_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->justification = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_justification_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_justification_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->justification);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_attach_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_attach_dir_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_dir);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_attach_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_top_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_attach_top_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_top = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_top_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_top);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_attach_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_bottom_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_attach_bottom_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_bottom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_attach_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_attach_bottom_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_bottom);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_text_extended_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MULTILEADER_is_text_extended_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_text_extended_set" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MULTILEADER_is_text_extended_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_text_extended = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MULTILEADER_is_text_extended_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MULTILEADER_is_text_extended_get" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_text_extended);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MULTILEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MULTILEADER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MULTILEADER *)calloc(1, sizeof(struct _dwg_entity_MULTILEADER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MULTILEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MULTILEADER *arg1 = (struct _dwg_entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MULTILEADER" "', argument " "1"" of type '" "struct _dwg_entity_MULTILEADER *""'"); 
  }
  arg1 = (struct _dwg_entity_MULTILEADER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MULTILEADER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MULTILEADER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_content_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_content_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_content_type_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_content_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->content_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_content_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_content_type_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->content_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_mleader_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_mleader_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_mleader_order_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_mleader_order_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->mleader_order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_mleader_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_mleader_order_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->mleader_order);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_leader_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_leader_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_leader_order_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_leader_order_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->leader_order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_leader_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_leader_order_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->leader_order);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_max_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_max_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_max_points_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_max_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->max_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_max_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_max_points_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->max_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_first_seg_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_first_seg_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_first_seg_angle_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_first_seg_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->first_seg_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_first_seg_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_first_seg_angle_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->first_seg_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_second_seg_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_second_seg_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_second_seg_angle_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_second_seg_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->second_seg_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_second_seg_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_second_seg_angle_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->second_seg_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_type_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_type_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_line_color_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_line_color_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_line_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_line_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_line_type_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_line_type_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->line_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_line_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_line_type_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->line_type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_landing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_has_landing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_landing_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_has_landing_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_landing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_landing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_landing_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_landing);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_dogleg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_has_dogleg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_dogleg_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_has_dogleg_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_dogleg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_dogleg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_dogleg_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_dogleg);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_landing_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_landing_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_landing_gap_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_landing_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->landing_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_landing_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_landing_gap_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->landing_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_landing_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_landing_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_landing_dist_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_landing_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->landing_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_landing_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_landing_dist_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->landing_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_description_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_description_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_arrow_head_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_arrow_head_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_head = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_arrow_head_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_head);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_arrow_head_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_arrow_head_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_size_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_head_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_arrow_head_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_arrow_head_size_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_head_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_default_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_text_default_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_default);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_default = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_default = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_default_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_default);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_style_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_style_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_attach_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_left_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_attach_left_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_left = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_left_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_left);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_attach_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_right_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_attach_right_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_right = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_right_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_right);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_angle_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_angle_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_angle_type_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_text_angle_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_angle_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_angle_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_angle_type_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_angle_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_align_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_align_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_align_type_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_text_align_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_align_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_align_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_align_type_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_align_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_color_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_text_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->text_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_color_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->text_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_height_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_height_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_text_frame_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_has_text_frame_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_text_frame_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_has_text_frame_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_text_frame = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_has_text_frame_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_has_text_frame_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_text_frame);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_always_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_always_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_always_left_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_text_always_left_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->text_always_left = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_always_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_always_left_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->text_always_left);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_align_space_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_align_space_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_align_space_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_align_space_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->align_space = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_align_space_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_align_space_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->align_space);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_block_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_color_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_block_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->block_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_color_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->block_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADERSTYLE_block_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->block_scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->block_scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_use_block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_use_block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_scale_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_block_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_use_block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->use_block_scale);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_block_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_block_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->block_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->block_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_use_block_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_use_block_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_rotation_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_block_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_use_block_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_use_block_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->use_block_rotation);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_connection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_block_connection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_connection_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_block_connection_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->block_connection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_block_connection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_block_connection_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->block_connection);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_is_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_is_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_is_changed_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_is_changed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_changed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_is_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_is_changed_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_changed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_is_annotative_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_is_annotative_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_is_annotative_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_is_annotative_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_annotative = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_is_annotative_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_is_annotative_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_annotative);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_break_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_break_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_break_size_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_break_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->break_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_break_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_break_size_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->break_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_attach_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_dir_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_attach_dir_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_dir_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_dir);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_attach_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_top_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_attach_top_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_top = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_top_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_top);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_attach_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_bottom_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_attach_bottom_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->attach_bottom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_attach_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_attach_bottom_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->attach_bottom);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_extended_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADERSTYLE_text_extended_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_extended_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADERSTYLE_text_extended_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->text_extended = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADERSTYLE_text_extended_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADERSTYLE_text_extended_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->text_extended);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MLEADERSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MLEADERSTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MLEADERSTYLE *)calloc(1, sizeof(struct _dwg_object_MLEADERSTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLEADERSTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MLEADERSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADERSTYLE *arg1 = (struct _dwg_object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADERSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MLEADERSTYLE" "', argument " "1"" of type '" "struct _dwg_object_MLEADERSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADERSTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MLEADERSTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MLEADERSTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MLEADERSTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VBA_PROJECT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VBA_PROJECT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VBA_PROJECT_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_data_size_set" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VBA_PROJECT_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_data_size_get" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VBA_PROJECT_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_data_set" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VBA_PROJECT_data_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VBA_PROJECT_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VBA_PROJECT_data_get" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  result = (BITCODE_TF) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VBA_PROJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VBA_PROJECT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VBA_PROJECT *)calloc(1, sizeof(struct _dwg_object_VBA_PROJECT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VBA_PROJECT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VBA_PROJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VBA_PROJECT *arg1 = (struct _dwg_object_VBA_PROJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VBA_PROJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VBA_PROJECT" "', argument " "1"" of type '" "struct _dwg_object_VBA_PROJECT *""'"); 
  }
  arg1 = (struct _dwg_object_VBA_PROJECT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VBA_PROJECT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VBA_PROJECT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VBA_PROJECT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_printer_cfg_file_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_printer_cfg_file_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_printer_cfg_file_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_printer_cfg_file_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->printer_cfg_file);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->printer_cfg_file = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->printer_cfg_file = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_printer_cfg_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_printer_cfg_file_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->printer_cfg_file);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_paper_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_size_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_paper_size_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->paper_size);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->paper_size = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->paper_size = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_size_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->paper_size);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_canonical_media_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_canonical_media_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_canonical_media_name_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_canonical_media_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->canonical_media_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->canonical_media_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->canonical_media_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_canonical_media_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_canonical_media_name_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->canonical_media_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_flags_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->plot_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_flags_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->plot_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plotview_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plotview_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->plotview = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plotview_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_H) ((arg1)->plotview);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plotview_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plotview_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_name_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->plotview_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->plotview_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->plotview_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plotview_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plotview_name_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->plotview_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_left_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_left_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_left_margin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_left_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->left_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_left_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_left_margin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->left_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_bottom_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_bottom_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_bottom_margin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_bottom_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bottom_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_bottom_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_bottom_margin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->bottom_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_right_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_right_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_right_margin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_right_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->right_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_right_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_right_margin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->right_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_top_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_top_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_top_margin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_top_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->top_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_top_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_top_margin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->top_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_paper_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_width_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_paper_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->paper_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_width_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->paper_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_paper_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_height_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_paper_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->paper_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_height_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->paper_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_2BD_1 *arg2 = (BITCODE_2BD_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_origin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_origin_set" "', argument " "2"" of type '" "BITCODE_2BD_1 *""'"); 
  }
  arg2 = (BITCODE_2BD_1 *)(argp2);
  if (arg1) (arg1)->plot_origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD_1 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_origin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_2BD_1 *)& ((arg1)->plot_origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_window_ll_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_2BD_1 *arg2 = (BITCODE_2BD_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_window_ll_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ll_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ll_set" "', argument " "2"" of type '" "BITCODE_2BD_1 *""'"); 
  }
  arg2 = (BITCODE_2BD_1 *)(argp2);
  if (arg1) (arg1)->plot_window_ll = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_window_ll_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD_1 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ll_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_2BD_1 *)& ((arg1)->plot_window_ll);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_window_ur_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_2BD_1 *arg2 = (BITCODE_2BD_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_window_ur_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ur_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ur_set" "', argument " "2"" of type '" "BITCODE_2BD_1 *""'"); 
  }
  arg2 = (BITCODE_2BD_1 *)(argp2);
  if (arg1) (arg1)->plot_window_ur = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_window_ur_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD_1 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_window_ur_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_2BD_1 *)& ((arg1)->plot_window_ur);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_paper_unit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_paper_unit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_paper_unit_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_paper_unit_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->plot_paper_unit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_paper_unit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_paper_unit_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->plot_paper_unit);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->plot_rotation_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_rotation_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->plot_rotation_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_plot_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_type_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_plot_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->plot_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_plot_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_plot_type_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->plot_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_paper_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_units_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_paper_units_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->paper_units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_units_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->paper_units);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_drawing_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_drawing_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_drawing_units_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_drawing_units_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->drawing_units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_drawing_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_drawing_units_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->drawing_units);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_stylesheet_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_stylesheet_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_stylesheet_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_stylesheet_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->stylesheet);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->stylesheet = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->stylesheet = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_stylesheet_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_stylesheet_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->stylesheet);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_std_scale_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_std_scale_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_type_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->std_scale_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_std_scale_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_type_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->std_scale_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_std_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_std_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->std_scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_std_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_std_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->std_scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_image_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_2BD_1 *arg2 = (BITCODE_2BD_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_paper_image_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_image_origin_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_paper_image_origin_set" "', argument " "2"" of type '" "BITCODE_2BD_1 *""'"); 
  }
  arg2 = (BITCODE_2BD_1 *)(argp2);
  if (arg1) (arg1)->paper_image_origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_paper_image_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD_1 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_paper_image_origin_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_2BD_1 *)& ((arg1)->paper_image_origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_shadeplot_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_type_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadeplot_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_type_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadeplot_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadeplot_reslevel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadeplot_reslevel);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadeplot_customdpi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadeplot_customdpi);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PLOTSETTINGS_shadeplot_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_set" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->shadeplot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PLOTSETTINGS_shadeplot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PLOTSETTINGS_shadeplot_get" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  result = (BITCODE_H) ((arg1)->shadeplot);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_PLOTSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_PLOTSETTINGS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_PLOTSETTINGS *)calloc(1, sizeof(struct _dwg_object_PLOTSETTINGS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLOTSETTINGS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_PLOTSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PLOTSETTINGS *arg1 = (struct _dwg_object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PLOTSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_PLOTSETTINGS" "', argument " "1"" of type '" "struct _dwg_object_PLOTSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_PLOTSETTINGS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_PLOTSETTINGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_PLOTSETTINGS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_PLOTSETTINGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_plotsettings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  Dwg_Object_PLOTSETTINGS *arg2 = (Dwg_Object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_plotsettings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_plotsettings_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_plotsettings_set" "', argument " "2"" of type '" "Dwg_Object_PLOTSETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_PLOTSETTINGS *)(argp2);
  if (arg1) (arg1)->plotsettings = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_plotsettings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLOTSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_plotsettings_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (Dwg_Object_PLOTSETTINGS *)& ((arg1)->plotsettings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_layout_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_layout_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_layout_name_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_layout_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->layout_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->layout_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->layout_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_layout_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_layout_name_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_TV) ((arg1)->layout_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_tab_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_tab_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_tab_order_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYOUT_tab_order_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->tab_order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_tab_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_tab_order_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_BS) ((arg1)->tab_order);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_layout_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_layout_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_layout_flags_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYOUT_layout_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->layout_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_layout_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_layout_flags_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_BS) ((arg1)->layout_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_INSBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_INSBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_INSBASE_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_INSBASE_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->INSBASE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_INSBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_INSBASE_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->INSBASE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_LIMMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_LIMMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_LIMMIN_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_LIMMIN_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->LIMMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_LIMMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_LIMMIN_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->LIMMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_LIMMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_2DPOINT *arg2 = (BITCODE_2DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_LIMMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_LIMMAX_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_LIMMAX_set" "', argument " "2"" of type '" "BITCODE_2DPOINT *""'"); 
  }
  arg2 = (BITCODE_2DPOINT *)(argp2);
  if (arg1) (arg1)->LIMMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_LIMMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_LIMMAX_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_2DPOINT *)& ((arg1)->LIMMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSORG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_UCSORG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSORG_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_UCSORG_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->UCSORG = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSORG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSORG_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->UCSORG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSXDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_UCSXDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSXDIR_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_UCSXDIR_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->UCSXDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSXDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSXDIR_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->UCSXDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSYDIR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_UCSYDIR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSYDIR_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_UCSYDIR_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->UCSYDIR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSYDIR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSYDIR_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->UCSYDIR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_ucs_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_ucs_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_ucs_elevation_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYOUT_ucs_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ucs_elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_ucs_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_ucs_elevation_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_BD) ((arg1)->ucs_elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSORTHOVIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_UCSORTHOVIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSORTHOVIEW_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYOUT_UCSORTHOVIEW_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->UCSORTHOVIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_UCSORTHOVIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_UCSORTHOVIEW_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_BS) ((arg1)->UCSORTHOVIEW);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_EXTMIN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_EXTMIN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_EXTMIN_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_EXTMIN_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->EXTMIN = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_EXTMIN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_EXTMIN_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->EXTMIN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_EXTMAX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_EXTMAX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_EXTMAX_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_EXTMAX_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->EXTMAX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_EXTMAX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_EXTMAX_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->EXTMAX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_block_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_block_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_block_header_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_block_header_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_header = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_block_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_block_header_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->block_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_active_viewport_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_active_viewport_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_active_viewport_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_active_viewport_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->active_viewport = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_active_viewport_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_active_viewport_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->active_viewport);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_base_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_base_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_base_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_base_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->base_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_base_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_base_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->base_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_named_ucs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_named_ucs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_named_ucs_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_named_ucs_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->named_ucs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_named_ucs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_named_ucs_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->named_ucs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_num_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_num_viewports_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_num_viewports_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYOUT_num_viewports_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_viewports = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_num_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_num_viewports_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_viewports);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYOUT_viewports_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_viewports_set" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYOUT_viewports_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->viewports = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYOUT_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYOUT_viewports_get" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  result = (BITCODE_H *) ((arg1)->viewports);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LAYOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LAYOUT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LAYOUT *)calloc(1, sizeof(struct _dwg_object_LAYOUT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYOUT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LAYOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYOUT *arg1 = (struct _dwg_object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYOUT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LAYOUT" "', argument " "1"" of type '" "struct _dwg_object_LAYOUT *""'"); 
  }
  arg1 = (struct _dwg_object_LAYOUT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LAYOUT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LAYOUT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LAYOUT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYVAR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYVAR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_schema_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYVAR_schema_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_schema_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DICTIONARYVAR_schema_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->schema = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_schema_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_schema_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  result = (BITCODE_RC) ((arg1)->schema);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_strvalue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DICTIONARYVAR_strvalue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_strvalue_set" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DICTIONARYVAR_strvalue_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->strvalue);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->strvalue = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->strvalue = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DICTIONARYVAR_strvalue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DICTIONARYVAR_strvalue_get" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  result = (BITCODE_TV) ((arg1)->strvalue);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DICTIONARYVAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DICTIONARYVAR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DICTIONARYVAR *)calloc(1, sizeof(struct _dwg_object_DICTIONARYVAR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYVAR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DICTIONARYVAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DICTIONARYVAR *arg1 = (struct _dwg_object_DICTIONARYVAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DICTIONARYVAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DICTIONARYVAR" "', argument " "1"" of type '" "struct _dwg_object_DICTIONARYVAR *""'"); 
  }
  arg1 = (struct _dwg_object_DICTIONARYVAR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DICTIONARYVAR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DICTIONARYVAR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DICTIONARYVAR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_flags_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_flags_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_format_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_format_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_format_flags_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_format_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->format_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_format_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_format_flags_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->format_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_type_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_data_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_type_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_size_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_data_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_size_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_long_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_long_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_long_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_data_long_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_long = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_long_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_long_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_long);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_double_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_double_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_double_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_data_double_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->data_double = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_double_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_double_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BD) ((arg1)->data_double);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_string_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_data_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->data_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->data_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->data_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_string_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_TV) ((arg1)->data_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_date_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_date_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_date_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_data_date_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->data_date = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_date_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_date_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_TF) ((arg1)->data_date);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_point_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_data_point_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->data_point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_point_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->data_point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_3dpoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_3dpoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_3dpoint_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_data_3dpoint_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->data_3dpoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_3dpoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_3dpoint_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->data_3dpoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_data_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_handle_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_data_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->data_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_data_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_data_handle_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_H) ((arg1)->data_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_unit_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_unit_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_unit_type_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_value_unit_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unit_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_unit_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_unit_type_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->unit_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_format_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_format_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_format_string_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_format_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->format_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->format_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->format_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_format_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_format_string_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_TV) ((arg1)->format_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_value_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_value_value_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_value_string_set" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_value_value_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->value_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->value_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->value_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_value_value_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_value_value_string_get" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  result = (BITCODE_TV) ((arg1)->value_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_value", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_value *)calloc(1, sizeof(struct _dwg_TABLE_value));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_value *arg1 = (struct _dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_value, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_value" "', argument " "1"" of type '" "struct _dwg_TABLE_value *""'"); 
  }
  arg1 = (struct _dwg_TABLE_value *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_value_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_value, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_value_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_CustomDataItem_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_name_set" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_CustomDataItem_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_name_get" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_CustomDataItem_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_value_set" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_CustomDataItem_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_value_get" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_cell_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  struct _dwg_TableCell *arg2 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_CustomDataItem_cell_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_cell_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_CustomDataItem_cell_parent_set" "', argument " "2"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg2 = (struct _dwg_TableCell *)(argp2);
  if (arg1) (arg1)->cell_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_cell_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableCell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_cell_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  result = (struct _dwg_TableCell *) ((arg1)->cell_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_row_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  struct _dwg_TableRow *arg2 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_CustomDataItem_row_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_row_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_CustomDataItem_row_parent_set" "', argument " "2"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg2 = (struct _dwg_TableRow *)(argp2);
  if (arg1) (arg1)->row_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_CustomDataItem_row_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableRow *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_CustomDataItem_row_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  result = (struct _dwg_TableRow *) ((arg1)->row_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_CustomDataItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_CustomDataItem", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_CustomDataItem *)calloc(1, sizeof(struct _dwg_TABLE_CustomDataItem));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_CustomDataItem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_CustomDataItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_CustomDataItem *arg1 = (struct _dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_CustomDataItem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_CustomDataItem" "', argument " "1"" of type '" "struct _dwg_TABLE_CustomDataItem *""'"); 
  }
  arg1 = (struct _dwg_TABLE_CustomDataItem *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_CustomDataItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_CustomDataItem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_CustomDataItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  struct _dwg_TABLE_Cell *arg2 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_AttrDef_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_AttrDef_parent_set" "', argument " "2"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg2 = (struct _dwg_TABLE_Cell *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TABLE_Cell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  result = (struct _dwg_TABLE_Cell *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_attdef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_AttrDef_attdef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_attdef_set" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_AttrDef_attdef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->attdef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_attdef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_attdef_get" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  result = (BITCODE_H) ((arg1)->attdef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_AttrDef_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_index_set" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_AttrDef_index_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_index_get" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  result = (BITCODE_BS) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_AttrDef_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_text_set" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_AttrDef_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_AttrDef_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_AttrDef_text_get" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_AttrDef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_AttrDef", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_AttrDef *)calloc(1, sizeof(struct _dwg_TABLE_AttrDef));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_AttrDef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_AttrDef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_AttrDef *arg1 = (struct _dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_AttrDef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_AttrDef" "', argument " "1"" of type '" "struct _dwg_TABLE_AttrDef *""'"); 
  }
  arg1 = (struct _dwg_TABLE_AttrDef *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_AttrDef_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_AttrDef, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_AttrDef_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  struct _dwg_entity_TABLE *arg2 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg2 = (struct _dwg_entity_TABLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_TABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (struct _dwg_entity_TABLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_type_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_type_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_flags_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_flags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_flags_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_RC) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_is_merged_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_is_merged_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_is_merged_value_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_is_merged_value_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_merged_value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_is_merged_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_is_merged_value_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_B) ((arg1)->is_merged_value);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_is_autofit_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_is_autofit_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_is_autofit_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_is_autofit_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_autofit_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_is_autofit_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_is_autofit_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_B) ((arg1)->is_autofit_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_merged_width_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_merged_width_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_merged_width_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_merged_width_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->merged_width_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_merged_width_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_merged_width_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->merged_width_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_merged_height_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_merged_height_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_merged_height_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_merged_height_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->merged_height_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_merged_height_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_merged_height_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->merged_height_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_rotation_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_rotation_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_value_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_value_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_style_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_style_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_block_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_block_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_block_handle_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_block_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_block_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_block_handle_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_H) ((arg1)->block_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_block_scale_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_block_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->block_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_block_scale_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BD) ((arg1)->block_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_additional_data_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_additional_data_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_additional_data_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_additional_data_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->additional_data_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_additional_data_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_additional_data_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_B) ((arg1)->additional_data_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_cell_flag_override_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_cell_flag_override_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_cell_flag_override_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_cell_flag_override_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->cell_flag_override = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_cell_flag_override_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_cell_flag_override_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->cell_flag_override);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_virtual_edge_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_virtual_edge_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_virtual_edge_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_virtual_edge_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->virtual_edge_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_virtual_edge_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_virtual_edge_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_RC) ((arg1)->virtual_edge_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_cell_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_cell_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_cell_alignment_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_cell_alignment_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->cell_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_cell_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_cell_alignment_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_RS) ((arg1)->cell_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bg_fill_none_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_bg_fill_none_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bg_fill_none_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_bg_fill_none_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_fill_none = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bg_fill_none_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bg_fill_none_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_fill_none);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bg_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_bg_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bg_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_bg_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bg_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bg_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bg_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bg_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_content_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_content_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_content_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_content_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->content_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_content_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_content_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->content_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_height_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_text_height_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_grid_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_top_grid_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_grid_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_top_grid_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->top_grid_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_grid_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_grid_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->top_grid_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_grid_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_top_grid_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_grid_linewt_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_top_grid_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->top_grid_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_grid_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_grid_linewt_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->top_grid_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_top_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_visibility_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_top_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->top_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_top_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_top_visibility_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->top_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_grid_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_right_grid_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_grid_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_right_grid_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->right_grid_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_grid_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_grid_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->right_grid_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_grid_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_right_grid_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_grid_linewt_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_right_grid_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->right_grid_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_grid_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_grid_linewt_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->right_grid_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_right_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_visibility_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_right_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->right_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_right_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_right_visibility_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->right_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_grid_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_bottom_grid_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_grid_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_bottom_grid_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bottom_grid_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_grid_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_grid_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bottom_grid_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_grid_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_bottom_grid_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_grid_linewt_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_bottom_grid_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bottom_grid_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_grid_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_grid_linewt_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->bottom_grid_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_bottom_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_visibility_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_bottom_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bottom_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_bottom_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_bottom_visibility_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->bottom_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_grid_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_left_grid_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_grid_color_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_left_grid_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->left_grid_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_grid_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_grid_color_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->left_grid_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_grid_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_left_grid_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_grid_linewt_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_left_grid_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->left_grid_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_grid_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_grid_linewt_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->left_grid_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_left_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_visibility_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_left_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->left_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_left_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_left_visibility_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BS) ((arg1)->left_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_unknown_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_unknown_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_unknown_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_value_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_value_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_num_attr_defs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_num_attr_defs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_num_attr_defs_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_Cell_num_attr_defs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_attr_defs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_num_attr_defs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_num_attr_defs_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_attr_defs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_attr_defs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  Dwg_TABLE_AttrDef *arg2 = (Dwg_TABLE_AttrDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_Cell_attr_defs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_attr_defs_set" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_AttrDef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_Cell_attr_defs_set" "', argument " "2"" of type '" "Dwg_TABLE_AttrDef *""'"); 
  }
  arg2 = (Dwg_TABLE_AttrDef *)(argp2);
  if (arg1) (arg1)->attr_defs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_Cell_attr_defs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_AttrDef *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_Cell_attr_defs_get" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  result = (Dwg_TABLE_AttrDef *) ((arg1)->attr_defs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_AttrDef, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_Cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_Cell", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_Cell *)calloc(1, sizeof(struct _dwg_TABLE_Cell));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_Cell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_Cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_Cell *arg1 = (struct _dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_Cell" "', argument " "1"" of type '" "struct _dwg_TABLE_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLE_Cell *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_Cell_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_Cell, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_Cell_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  struct _dwg_entity_TABLE *arg2 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakHeight_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_BreakHeight_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg2 = (struct _dwg_entity_TABLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_TABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  result = (struct _dwg_entity_TABLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakHeight_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_position_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_BreakHeight_position_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_position_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakHeight_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_height_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_BreakHeight_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_height_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakHeight_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_BreakHeight_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakHeight_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakHeight_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  result = (BITCODE_BL) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_BreakHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_BreakHeight", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_BreakHeight *)calloc(1, sizeof(struct _dwg_TABLE_BreakHeight));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_BreakHeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_BreakHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakHeight *arg1 = (struct _dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakHeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_BreakHeight" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakHeight *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakHeight *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_BreakHeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_BreakHeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_BreakHeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  struct _dwg_entity_TABLE *arg2 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakRow_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_BreakRow_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg2 = (struct _dwg_entity_TABLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_TABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  result = (struct _dwg_entity_TABLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakRow_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_position_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLE_BreakRow_position_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_position_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakRow_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_start_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_BreakRow_start_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_start_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLE_BreakRow_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_end_set" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLE_BreakRow_end_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLE_BreakRow_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLE_BreakRow_end_get" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->end);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLE_BreakRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLE_BreakRow", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLE_BreakRow *)calloc(1, sizeof(struct _dwg_TABLE_BreakRow));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_BreakRow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLE_BreakRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLE_BreakRow *arg1 = (struct _dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLE_BreakRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLE_BreakRow" "', argument " "1"" of type '" "struct _dwg_TABLE_BreakRow *""'"); 
  }
  arg1 = (struct _dwg_TABLE_BreakRow *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLE_BreakRow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLE_BreakRow, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLE_BreakRow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LinkedData_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *arg1 = (struct _dwg_LinkedData *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedData_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedData_name_set" "', argument " "1"" of type '" "struct _dwg_LinkedData *""'"); 
  }
  arg1 = (struct _dwg_LinkedData *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LinkedData_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedData_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *arg1 = (struct _dwg_LinkedData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedData_name_get" "', argument " "1"" of type '" "struct _dwg_LinkedData *""'"); 
  }
  arg1 = (struct _dwg_LinkedData *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedData_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *arg1 = (struct _dwg_LinkedData *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedData_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedData_description_set" "', argument " "1"" of type '" "struct _dwg_LinkedData *""'"); 
  }
  arg1 = (struct _dwg_LinkedData *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LinkedData_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedData_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *arg1 = (struct _dwg_LinkedData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedData_description_get" "', argument " "1"" of type '" "struct _dwg_LinkedData *""'"); 
  }
  arg1 = (struct _dwg_LinkedData *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LinkedData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LinkedData", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LinkedData *)calloc(1, sizeof(struct _dwg_LinkedData));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LinkedData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedData *arg1 = (struct _dwg_LinkedData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LinkedData" "', argument " "1"" of type '" "struct _dwg_LinkedData *""'"); 
  }
  arg1 = (struct _dwg_LinkedData *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LinkedData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LinkedData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LinkedData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  struct _dwg_TableCellContent *arg2 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_Attr_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_parent_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCellContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_Attr_parent_set" "', argument " "2"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg2 = (struct _dwg_TableCellContent *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableCellContent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_parent_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  result = (struct _dwg_TableCellContent *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_attdef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_Attr_attdef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_attdef_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_Attr_attdef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->attdef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_attdef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_attdef_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  result = (BITCODE_H) ((arg1)->attdef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_Attr_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_value_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_Attr_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_value_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  result = (BITCODE_TV) ((arg1)->value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_Attr_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_index_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCellContent_Attr_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_Attr_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_Attr_index_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  result = (BITCODE_BL) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TableCellContent_Attr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TableCellContent_Attr", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TableCellContent_Attr *)calloc(1, sizeof(struct _dwg_TableCellContent_Attr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCellContent_Attr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TableCellContent_Attr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent_Attr *arg1 = (struct _dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent_Attr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TableCellContent_Attr" "', argument " "1"" of type '" "struct _dwg_TableCellContent_Attr *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent_Attr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TableCellContent_Attr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TableCellContent_Attr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TableCellContent_Attr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_property_override_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_property_override_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_property_override_flags_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_property_override_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->property_override_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_property_override_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_property_override_flags_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->property_override_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_property_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_property_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_property_flags_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_property_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->property_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_property_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_property_flags_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->property_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_data_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_value_data_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_data_type_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_value_data_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->value_data_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_data_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_data_type_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->value_data_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_unit_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_value_unit_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_unit_type_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_value_unit_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->value_unit_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_unit_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_unit_type_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->value_unit_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_format_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_value_format_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_format_string_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ContentFormat_value_format_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->value_format_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->value_format_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->value_format_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_value_format_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_value_format_string_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_TV) ((arg1)->value_format_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_rotation_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_rotation_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_block_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_block_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_block_scale_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_block_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->block_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_block_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_block_scale_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BD) ((arg1)->block_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_cell_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_cell_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_cell_alignment_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_cell_alignment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->cell_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_cell_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_cell_alignment_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->cell_alignment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_content_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_content_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_content_color_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ContentFormat_content_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->content_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_content_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_content_color_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->content_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_text_style_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ContentFormat_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_text_style_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ContentFormat_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_text_height_set" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ContentFormat_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ContentFormat_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ContentFormat_text_height_get" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ContentFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ContentFormat", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ContentFormat *)calloc(1, sizeof(struct _dwg_ContentFormat));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ContentFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ContentFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ContentFormat *arg1 = (struct _dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ContentFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ContentFormat" "', argument " "1"" of type '" "struct _dwg_ContentFormat *""'"); 
  }
  arg1 = (struct _dwg_ContentFormat *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ContentFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ContentFormat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ContentFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  struct _dwg_TableCell *arg2 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_parent_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_parent_set" "', argument " "2"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg2 = (struct _dwg_TableCell *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableCell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_parent_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (struct _dwg_TableCell *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_type_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCellContent_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_type_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (BITCODE_BL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_value_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_value_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_handle_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_handle_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_num_attrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_num_attrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_num_attrs_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCellContent_num_attrs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_attrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_num_attrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_num_attrs_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_attrs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_attrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  Dwg_TableCellContent_Attr *arg2 = (Dwg_TableCellContent_Attr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_attrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_attrs_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCellContent_Attr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_attrs_set" "', argument " "2"" of type '" "Dwg_TableCellContent_Attr *""'"); 
  }
  arg2 = (Dwg_TableCellContent_Attr *)(argp2);
  if (arg1) (arg1)->attrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_attrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TableCellContent_Attr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_attrs_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (Dwg_TableCellContent_Attr *) ((arg1)->attrs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCellContent_Attr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_has_content_format_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_has_content_format_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_has_content_format_overrides_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCellContent_has_content_format_overrides_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->has_content_format_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_has_content_format_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_has_content_format_overrides_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (BITCODE_BS) ((arg1)->has_content_format_overrides);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_content_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  Dwg_ContentFormat *arg2 = (Dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCellContent_content_format_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_content_format_set" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCellContent_content_format_set" "', argument " "2"" of type '" "Dwg_ContentFormat *""'"); 
  }
  arg2 = (Dwg_ContentFormat *)(argp2);
  if (arg1) (arg1)->content_format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCellContent_content_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ContentFormat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCellContent_content_format_get" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  result = (Dwg_ContentFormat *)& ((arg1)->content_format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TableCellContent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TableCellContent", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TableCellContent *)calloc(1, sizeof(struct _dwg_TableCellContent));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCellContent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TableCellContent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCellContent *arg1 = (struct _dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCellContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TableCellContent" "', argument " "1"" of type '" "struct _dwg_TableCellContent *""'"); 
  }
  arg1 = (struct _dwg_TableCellContent *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TableCellContent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TableCellContent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TableCellContent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_dist_top_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_dist_top_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_dist_top_left_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellContentGeometry_dist_top_left_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->dist_top_left = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_dist_top_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_dist_top_left_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->dist_top_left);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_dist_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_dist_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_dist_center_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellContentGeometry_dist_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->dist_center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_dist_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_dist_center_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->dist_center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_content_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_content_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_content_width_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellContentGeometry_content_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->content_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_content_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_content_width_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_BD) ((arg1)->content_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_content_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_content_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_content_height_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellContentGeometry_content_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->content_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_content_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_content_height_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_BD) ((arg1)->content_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_width_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellContentGeometry_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_width_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_height_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellContentGeometry_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_height_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_unknown_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellContentGeometry_unknown_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_unknown_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_cell_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  struct _dwg_TableCell *arg2 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_cell_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_cell_parent_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellContentGeometry_cell_parent_set" "', argument " "2"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg2 = (struct _dwg_TableCell *)(argp2);
  if (arg1) (arg1)->cell_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_cell_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableCell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_cell_parent_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (struct _dwg_TableCell *) ((arg1)->cell_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_geom_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  struct _dwg_TABLEGEOMETRY_Cell *arg2 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellContentGeometry_geom_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_geom_parent_set" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellContentGeometry_geom_parent_set" "', argument " "2"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg2 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp2);
  if (arg1) (arg1)->geom_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellContentGeometry_geom_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TABLEGEOMETRY_Cell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellContentGeometry_geom_parent_get" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  result = (struct _dwg_TABLEGEOMETRY_Cell *) ((arg1)->geom_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_CellContentGeometry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_CellContentGeometry", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_CellContentGeometry *)calloc(1, sizeof(struct _dwg_CellContentGeometry));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellContentGeometry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_CellContentGeometry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellContentGeometry *arg1 = (struct _dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellContentGeometry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_CellContentGeometry" "', argument " "1"" of type '" "struct _dwg_CellContentGeometry *""'"); 
  }
  arg1 = (struct _dwg_CellContentGeometry *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_CellContentGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_CellContentGeometry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_CellContentGeometry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TableCell_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_flag_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_flag_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_tooltip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_tooltip_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_tooltip_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_tooltip_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tooltip);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tooltip = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tooltip = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_tooltip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_tooltip_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_TV) ((arg1)->tooltip);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_customdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_customdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_customdata_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_customdata_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->customdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_customdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_customdata_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->customdata);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_customdata_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_num_customdata_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_customdata_items_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_num_customdata_items_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_customdata_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_customdata_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_customdata_items_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_customdata_items);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_customdata_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  Dwg_TABLE_CustomDataItem *arg2 = (Dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_customdata_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_customdata_items_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_CustomDataItem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_customdata_items_set" "', argument " "2"" of type '" "Dwg_TABLE_CustomDataItem *""'"); 
  }
  arg2 = (Dwg_TABLE_CustomDataItem *)(argp2);
  if (arg1) (arg1)->customdata_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_customdata_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_CustomDataItem *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_customdata_items_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (Dwg_TABLE_CustomDataItem *) ((arg1)->customdata_items);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_has_linked_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_has_linked_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_has_linked_data_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_has_linked_data_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->has_linked_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_has_linked_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_has_linked_data_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->has_linked_data);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_data_link_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_data_link_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_data_link_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_data_link_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->data_link = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_data_link_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_data_link_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_H) ((arg1)->data_link);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_rows_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_num_rows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_rows_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_cols_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_num_cols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_cols_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_unknown_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_unknown_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_unknown_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_cell_contents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_num_cell_contents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_cell_contents_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_num_cell_contents_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cell_contents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_cell_contents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_cell_contents_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cell_contents);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_cell_contents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  Dwg_TableCellContent *arg2 = (Dwg_TableCellContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_cell_contents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_cell_contents_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCellContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_cell_contents_set" "', argument " "2"" of type '" "Dwg_TableCellContent *""'"); 
  }
  arg2 = (Dwg_TableCellContent *)(argp2);
  if (arg1) (arg1)->cell_contents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_cell_contents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TableCellContent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_cell_contents_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (Dwg_TableCellContent *) ((arg1)->cell_contents);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCellContent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_style_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_style_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_style_id_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_style_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->style_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_style_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_style_id_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->style_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_has_geom_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_has_geom_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_has_geom_data_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_has_geom_data_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->has_geom_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_has_geom_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_has_geom_data_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->has_geom_data);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_geom_data_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_geom_data_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_geom_data_flag_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_geom_data_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geom_data_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_geom_data_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_geom_data_flag_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->geom_data_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_width_w_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_width_w_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_width_w_gap_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_width_w_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width_w_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_width_w_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_width_w_gap_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BD) ((arg1)->width_w_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_height_w_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_height_w_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_height_w_gap_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_height_w_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height_w_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_height_w_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_height_w_gap_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BD) ((arg1)->height_w_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_tablegeometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_tablegeometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_tablegeometry_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_tablegeometry_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->tablegeometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_tablegeometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_tablegeometry_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_H) ((arg1)->tablegeometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_num_geometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_geometry_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableCell_num_geometry_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_num_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_num_geometry_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geometry);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  Dwg_CellContentGeometry *arg2 = (Dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_geometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_geometry_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellContentGeometry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_geometry_set" "', argument " "2"" of type '" "Dwg_CellContentGeometry *""'"); 
  }
  arg2 = (Dwg_CellContentGeometry *)(argp2);
  if (arg1) (arg1)->geometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CellContentGeometry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_geometry_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (Dwg_CellContentGeometry *) ((arg1)->geometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_style_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  struct _dwg_CellStyle *arg2 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_style_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_style_parent_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_style_parent_set" "', argument " "2"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg2 = (struct _dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->style_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_style_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_style_parent_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (struct _dwg_CellStyle *) ((arg1)->style_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_row_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  struct _dwg_TableRow *arg2 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableCell_row_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_row_parent_set" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableCell_row_parent_set" "', argument " "2"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg2 = (struct _dwg_TableRow *)(argp2);
  if (arg1) (arg1)->row_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableCell_row_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableRow *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableCell_row_parent_get" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  result = (struct _dwg_TableRow *) ((arg1)->row_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TableCell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TableCell", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TableCell *)calloc(1, sizeof(struct _dwg_TableCell));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TableCell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableCell *arg1 = (struct _dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TableCell" "', argument " "1"" of type '" "struct _dwg_TableCell *""'"); 
  }
  arg1 = (struct _dwg_TableCell *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TableCell_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TableCell, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TableCell_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_GridFormat_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  struct _dwg_CellStyle *arg2 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_parent_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_GridFormat_parent_set" "', argument " "2"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg2 = (struct _dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_parent_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (struct _dwg_CellStyle *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_index_mask_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_index_mask_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_index_mask_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_index_mask_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->index_mask = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_index_mask_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_index_mask_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->index_mask);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_border_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_border_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_border_overrides_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_border_overrides_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->border_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_border_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_border_overrides_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->border_overrides);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_border_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_border_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_border_type_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_border_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->border_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_border_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_border_type_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_BL) ((arg1)->border_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_color_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_GridFormat_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_color_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_linewt_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_linewt_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_BLd) ((arg1)->linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_ltype_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_GridFormat_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_ltype_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_H) ((arg1)->ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_visible_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_visible_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_visible_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_visible_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->visible = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_visible_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_visible_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_B) ((arg1)->visible);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_double_line_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GridFormat_double_line_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_double_line_spacing_set" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GridFormat_double_line_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->double_line_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GridFormat_double_line_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GridFormat_double_line_spacing_get" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  result = (BITCODE_BD) ((arg1)->double_line_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_GridFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_GridFormat", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_GridFormat *)calloc(1, sizeof(struct _dwg_GridFormat));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GridFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_GridFormat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GridFormat *arg1 = (struct _dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GridFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_GridFormat" "', argument " "1"" of type '" "struct _dwg_GridFormat *""'"); 
  }
  arg1 = (struct _dwg_GridFormat *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_GridFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_GridFormat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_GridFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_CellStyle_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_type_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_type_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_data_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_data_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_data_flags_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_data_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_data_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_data_flags_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_property_override_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_property_override_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_property_override_flags_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_property_override_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->property_override_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_property_override_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_property_override_flags_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->property_override_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_merge_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_merge_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_merge_flags_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_merge_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->merge_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_merge_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_merge_flags_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->merge_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_bg_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_bg_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_bg_color_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellStyle_bg_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bg_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_bg_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_bg_color_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bg_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_content_layout_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_content_layout_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_content_layout_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_content_layout_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->content_layout = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_content_layout_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_content_layout_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->content_layout);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_content_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  Dwg_ContentFormat *arg2 = (Dwg_ContentFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_content_format_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_content_format_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellStyle_content_format_set" "', argument " "2"" of type '" "Dwg_ContentFormat *""'"); 
  }
  arg2 = (Dwg_ContentFormat *)(argp2);
  if (arg1) (arg1)->content_format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_content_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ContentFormat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_content_format_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (Dwg_ContentFormat *)& ((arg1)->content_format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ContentFormat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_override_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_margin_override_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_override_flags_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_margin_override_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->margin_override_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_override_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_override_flags_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BS) ((arg1)->margin_override_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_vert_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_vert_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_vert_margin_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_vert_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->vert_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_vert_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_vert_margin_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->vert_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_horiz_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_horiz_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_horiz_margin_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_horiz_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_horiz_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_horiz_margin_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_bottom_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_bottom_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_bottom_margin_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_bottom_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bottom_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_bottom_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_bottom_margin_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->bottom_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_right_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_right_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_right_margin_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_right_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->right_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_right_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_right_margin_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->right_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_horiz_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_margin_horiz_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_horiz_spacing_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_margin_horiz_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->margin_horiz_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_horiz_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_horiz_spacing_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->margin_horiz_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_vert_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_margin_vert_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_vert_spacing_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_margin_vert_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->margin_vert_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_margin_vert_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_margin_vert_spacing_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->margin_vert_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_num_borders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_num_borders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_num_borders_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CellStyle_num_borders_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_borders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_num_borders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_num_borders_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_borders);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_borders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  Dwg_GridFormat *arg2 = (Dwg_GridFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_borders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_borders_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_GridFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellStyle_borders_set" "', argument " "2"" of type '" "Dwg_GridFormat *""'"); 
  }
  arg2 = (Dwg_GridFormat *)(argp2);
  if (arg1) (arg1)->borders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_borders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_GridFormat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_borders_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (Dwg_GridFormat *) ((arg1)->borders);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GridFormat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_tablerow_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  struct _dwg_TableRow *arg2 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_tablerow_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_tablerow_parent_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellStyle_tablerow_parent_set" "', argument " "2"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg2 = (struct _dwg_TableRow *)(argp2);
  if (arg1) (arg1)->tablerow_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_tablerow_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableRow *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_tablerow_parent_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (struct _dwg_TableRow *) ((arg1)->tablerow_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_tabledatacolumn_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  struct _dwg_TableDataColumn *arg2 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CellStyle_tabledatacolumn_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_tabledatacolumn_parent_set" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableDataColumn, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CellStyle_tabledatacolumn_parent_set" "', argument " "2"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg2 = (struct _dwg_TableDataColumn *)(argp2);
  if (arg1) (arg1)->tabledatacolumn_parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CellStyle_tabledatacolumn_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_TableDataColumn *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CellStyle_tabledatacolumn_parent_get" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  result = (struct _dwg_TableDataColumn *) ((arg1)->tabledatacolumn_parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_CellStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_CellStyle", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_CellStyle *)calloc(1, sizeof(struct _dwg_CellStyle));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_CellStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CellStyle *arg1 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CellStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_CellStyle" "', argument " "1"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_CellStyle *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_CellStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_CellStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_CellStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TableRow_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  struct _dwg_LinkedTableData *arg2 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_parent_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedTableData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableRow_parent_set" "', argument " "2"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg2 = (struct _dwg_LinkedTableData *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_LinkedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_parent_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (struct _dwg_LinkedTableData *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_num_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_num_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_num_cells_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableRow_num_cells_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_num_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_num_cells_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cells);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  Dwg_TableCell *arg2 = (Dwg_TableCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_cells_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableRow_cells_set" "', argument " "2"" of type '" "Dwg_TableCell *""'"); 
  }
  arg2 = (Dwg_TableCell *)(argp2);
  if (arg1) (arg1)->cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TableCell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_cells_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (Dwg_TableCell *) ((arg1)->cells);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableCell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_custom_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_custom_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_custom_data_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableRow_custom_data_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->custom_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_custom_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_custom_data_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->custom_data);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_num_customdata_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_num_customdata_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_num_customdata_items_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableRow_num_customdata_items_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_customdata_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_num_customdata_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_num_customdata_items_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_customdata_items);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_customdata_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  Dwg_TABLE_CustomDataItem *arg2 = (Dwg_TABLE_CustomDataItem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_customdata_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_customdata_items_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_CustomDataItem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableRow_customdata_items_set" "', argument " "2"" of type '" "Dwg_TABLE_CustomDataItem *""'"); 
  }
  arg2 = (Dwg_TABLE_CustomDataItem *)(argp2);
  if (arg1) (arg1)->customdata_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_customdata_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_CustomDataItem *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_customdata_items_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (Dwg_TABLE_CustomDataItem *) ((arg1)->customdata_items);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_CustomDataItem, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_cellstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  Dwg_CellStyle *arg2 = (Dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_cellstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_cellstyle_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableRow_cellstyle_set" "', argument " "2"" of type '" "Dwg_CellStyle *""'"); 
  }
  arg2 = (Dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->cellstyle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_cellstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_cellstyle_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (Dwg_CellStyle *)& ((arg1)->cellstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_style_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_style_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_style_id_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableRow_style_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->style_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_style_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_style_id_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->style_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableRow_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_height_set" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableRow_height_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableRow_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableRow_height_get" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  result = (BITCODE_BL) ((arg1)->height);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TableRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TableRow", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TableRow *)calloc(1, sizeof(struct _dwg_TableRow));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TableRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableRow *arg1 = (struct _dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TableRow" "', argument " "1"" of type '" "struct _dwg_TableRow *""'"); 
  }
  arg1 = (struct _dwg_TableRow *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TableRow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TableRow, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TableRow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  struct _dwg_LinkedTableData *arg2 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_parent_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedTableData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableDataColumn_parent_set" "', argument " "2"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg2 = (struct _dwg_LinkedTableData *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_LinkedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_parent_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (struct _dwg_LinkedTableData *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_name_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableDataColumn_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_name_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_custom_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_custom_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_custom_data_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableDataColumn_custom_data_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->custom_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_custom_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_custom_data_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (BITCODE_BL) ((arg1)->custom_data);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_cellstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  Dwg_CellStyle *arg2 = (Dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_cellstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_cellstyle_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TableDataColumn_cellstyle_set" "', argument " "2"" of type '" "Dwg_CellStyle *""'"); 
  }
  arg2 = (Dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->cellstyle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_cellstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_cellstyle_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (Dwg_CellStyle *)& ((arg1)->cellstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_cellstyle_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_cellstyle_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_cellstyle_id_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableDataColumn_cellstyle_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->cellstyle_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_cellstyle_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_cellstyle_id_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (BITCODE_BL) ((arg1)->cellstyle_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TableDataColumn_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_width_set" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TableDataColumn_width_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TableDataColumn_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TableDataColumn_width_get" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  result = (BITCODE_BL) ((arg1)->width);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TableDataColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TableDataColumn", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TableDataColumn *)calloc(1, sizeof(struct _dwg_TableDataColumn));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableDataColumn, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TableDataColumn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TableDataColumn *arg1 = (struct _dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TableDataColumn, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TableDataColumn" "', argument " "1"" of type '" "struct _dwg_TableDataColumn *""'"); 
  }
  arg1 = (struct _dwg_TableDataColumn *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TableDataColumn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TableDataColumn, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TableDataColumn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_cols_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LinkedTableData_num_cols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_cols_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  Dwg_TableDataColumn *arg2 = (Dwg_TableDataColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_cols_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableDataColumn, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LinkedTableData_cols_set" "', argument " "2"" of type '" "Dwg_TableDataColumn *""'"); 
  }
  arg2 = (Dwg_TableDataColumn *)(argp2);
  if (arg1) (arg1)->cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TableDataColumn *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_cols_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (Dwg_TableDataColumn *) ((arg1)->cols);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableDataColumn, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_rows_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LinkedTableData_num_rows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_rows_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  Dwg_TableRow *arg2 = (Dwg_TableRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_rows_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TableRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LinkedTableData_rows_set" "', argument " "2"" of type '" "Dwg_TableRow *""'"); 
  }
  arg2 = (Dwg_TableRow *)(argp2);
  if (arg1) (arg1)->rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TableRow *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_rows_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (Dwg_TableRow *) ((arg1)->rows);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TableRow, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_field_refs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_num_field_refs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_field_refs_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LinkedTableData_num_field_refs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_field_refs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_num_field_refs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_num_field_refs_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_field_refs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_field_refs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LinkedTableData_field_refs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_field_refs_set" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LinkedTableData_field_refs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->field_refs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LinkedTableData_field_refs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LinkedTableData_field_refs_get" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  result = (BITCODE_H *) ((arg1)->field_refs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LinkedTableData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LinkedTableData", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LinkedTableData *)calloc(1, sizeof(struct _dwg_LinkedTableData));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedTableData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LinkedTableData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LinkedTableData *arg1 = (struct _dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LinkedTableData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LinkedTableData" "', argument " "1"" of type '" "struct _dwg_LinkedTableData *""'"); 
  }
  arg1 = (struct _dwg_LinkedTableData *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LinkedTableData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LinkedTableData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LinkedTableData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  struct _dwg_FormattedTableData *arg2 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableMerged_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_parent_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FormattedTableData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FormattedTableMerged_parent_set" "', argument " "2"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg2 = (struct _dwg_FormattedTableData *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_FormattedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_parent_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  result = (struct _dwg_FormattedTableData *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_top_row_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableMerged_top_row_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_top_row_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FormattedTableMerged_top_row_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->top_row = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_top_row_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_top_row_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  result = (BITCODE_BL) ((arg1)->top_row);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_left_col_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableMerged_left_col_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_left_col_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FormattedTableMerged_left_col_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->left_col = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_left_col_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_left_col_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  result = (BITCODE_BL) ((arg1)->left_col);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_bottom_row_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableMerged_bottom_row_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_bottom_row_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FormattedTableMerged_bottom_row_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bottom_row = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_bottom_row_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_bottom_row_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  result = (BITCODE_BL) ((arg1)->bottom_row);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_right_col_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableMerged_right_col_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_right_col_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FormattedTableMerged_right_col_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->right_col = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableMerged_right_col_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableMerged_right_col_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  result = (BITCODE_BL) ((arg1)->right_col);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_FormattedTableMerged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_FormattedTableMerged", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_FormattedTableMerged *)calloc(1, sizeof(struct _dwg_FormattedTableMerged));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableMerged, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_FormattedTableMerged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableMerged *arg1 = (struct _dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableMerged, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_FormattedTableMerged" "', argument " "1"" of type '" "struct _dwg_FormattedTableMerged *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableMerged *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_FormattedTableMerged_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_FormattedTableMerged, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_FormattedTableMerged_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  struct _dwg_object_TABLECONTENT *arg2 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableData_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_parent_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLECONTENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FormattedTableData_parent_set" "', argument " "2"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg2 = (struct _dwg_object_TABLECONTENT *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_TABLECONTENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_parent_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  result = (struct _dwg_object_TABLECONTENT *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_cellstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  Dwg_CellStyle *arg2 = (Dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableData_cellstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_cellstyle_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FormattedTableData_cellstyle_set" "', argument " "2"" of type '" "Dwg_CellStyle *""'"); 
  }
  arg2 = (Dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->cellstyle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_cellstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_cellstyle_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  result = (Dwg_CellStyle *)& ((arg1)->cellstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_num_merged_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableData_num_merged_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_num_merged_cells_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FormattedTableData_num_merged_cells_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_merged_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_num_merged_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_num_merged_cells_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_merged_cells);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_merged_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  Dwg_FormattedTableMerged *arg2 = (Dwg_FormattedTableMerged *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FormattedTableData_merged_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_merged_cells_set" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FormattedTableMerged, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FormattedTableData_merged_cells_set" "', argument " "2"" of type '" "Dwg_FormattedTableMerged *""'"); 
  }
  arg2 = (Dwg_FormattedTableMerged *)(argp2);
  if (arg1) (arg1)->merged_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FormattedTableData_merged_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FormattedTableMerged *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FormattedTableData_merged_cells_get" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  result = (Dwg_FormattedTableMerged *) ((arg1)->merged_cells);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableMerged, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_FormattedTableData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_FormattedTableData", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_FormattedTableData *)calloc(1, sizeof(struct _dwg_FormattedTableData));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_FormattedTableData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FormattedTableData *arg1 = (struct _dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FormattedTableData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_FormattedTableData" "', argument " "1"" of type '" "struct _dwg_FormattedTableData *""'"); 
  }
  arg1 = (struct _dwg_FormattedTableData *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_FormattedTableData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_FormattedTableData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_FormattedTableData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLECONTENT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLECONTENT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_ldata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  Dwg_LinkedData *arg2 = (Dwg_LinkedData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLECONTENT_ldata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_ldata_set" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLECONTENT_ldata_set" "', argument " "2"" of type '" "Dwg_LinkedData *""'"); 
  }
  arg2 = (Dwg_LinkedData *)(argp2);
  if (arg1) (arg1)->ldata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_ldata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LinkedData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_ldata_get" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  result = (Dwg_LinkedData *)& ((arg1)->ldata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_tdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  Dwg_LinkedTableData *arg2 = (Dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLECONTENT_tdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_tdata_set" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLECONTENT_tdata_set" "', argument " "2"" of type '" "Dwg_LinkedTableData *""'"); 
  }
  arg2 = (Dwg_LinkedTableData *)(argp2);
  if (arg1) (arg1)->tdata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_tdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LinkedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_tdata_get" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  result = (Dwg_LinkedTableData *)& ((arg1)->tdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_fdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  Dwg_FormattedTableData *arg2 = (Dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLECONTENT_fdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_fdata_set" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLECONTENT_fdata_set" "', argument " "2"" of type '" "Dwg_FormattedTableData *""'"); 
  }
  arg2 = (Dwg_FormattedTableData *)(argp2);
  if (arg1) (arg1)->fdata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_fdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FormattedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_fdata_get" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  result = (Dwg_FormattedTableData *)& ((arg1)->fdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_tablestyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLECONTENT_tablestyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_tablestyle_set" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLECONTENT_tablestyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->tablestyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLECONTENT_tablestyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLECONTENT_tablestyle_get" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  result = (BITCODE_H) ((arg1)->tablestyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_TABLECONTENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_TABLECONTENT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_TABLECONTENT *)calloc(1, sizeof(struct _dwg_object_TABLECONTENT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLECONTENT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_TABLECONTENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLECONTENT *arg1 = (struct _dwg_object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLECONTENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_TABLECONTENT" "', argument " "1"" of type '" "struct _dwg_object_TABLECONTENT *""'"); 
  }
  arg1 = (struct _dwg_object_TABLECONTENT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_TABLECONTENT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_TABLECONTENT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_TABLECONTENT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_ldata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_LinkedData *arg2 = (Dwg_LinkedData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_ldata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_ldata_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_ldata_set" "', argument " "2"" of type '" "Dwg_LinkedData *""'"); 
  }
  arg2 = (Dwg_LinkedData *)(argp2);
  if (arg1) (arg1)->ldata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_ldata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LinkedData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_ldata_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_LinkedData *)& ((arg1)->ldata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_tdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_LinkedTableData *arg2 = (Dwg_LinkedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_tdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_tdata_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_tdata_set" "', argument " "2"" of type '" "Dwg_LinkedTableData *""'"); 
  }
  arg2 = (Dwg_LinkedTableData *)(argp2);
  if (arg1) (arg1)->tdata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_tdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LinkedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_tdata_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_LinkedTableData *)& ((arg1)->tdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LinkedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_fdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_FormattedTableData *arg2 = (Dwg_FormattedTableData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_fdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_fdata_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_fdata_set" "', argument " "2"" of type '" "Dwg_FormattedTableData *""'"); 
  }
  arg2 = (Dwg_FormattedTableData *)(argp2);
  if (arg1) (arg1)->fdata = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_fdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FormattedTableData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_fdata_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_FormattedTableData *)& ((arg1)->fdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FormattedTableData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_tablestyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_tablestyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_tablestyle_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_tablestyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->tablestyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_tablestyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_tablestyle_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->tablestyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_rc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_rc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_rc_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_unknown_rc_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_rc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_rc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_rc_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_rc);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_h_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_h_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_h_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_unknown_h_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->unknown_h = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_h_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_h_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->unknown_h);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_bl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bl_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_unknown_bl_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bl_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_b_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_unknown_b_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_b_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bl1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_bl1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bl1_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_unknown_bl1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bl1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bl1_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_scale_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_scale_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_scale_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_scale_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_scale_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_scale_flag_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->scale_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_scale_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_scale_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BB) ((arg1)->scale_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_attribs_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_attribs);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_owned_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_owned_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_owned_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_flag_for_table_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_flag_for_table_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_flag_for_table_value_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_flag_for_table_value_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag_for_table_value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_flag_for_table_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_flag_for_table_value_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag_for_table_value);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_horiz_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_horiz_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_horiz_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_horiz_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->horiz_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_horiz_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_horiz_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->horiz_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_cols_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_cols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_cols_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_rows_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_rows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_rows_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_cells_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_cells_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = (unsigned long)(val2);
  if (arg1) (arg1)->num_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_cells_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (unsigned long) ((arg1)->num_cells);
  resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_col_widths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_col_widths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_col_widths_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_col_widths_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->col_widths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_col_widths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_col_widths_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->col_widths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_row_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_row_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_row_heights_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_row_heights_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->row_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_row_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_row_heights_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->row_heights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_TABLE_Cell *arg2 = (Dwg_TABLE_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_cells_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_cells_set" "', argument " "2"" of type '" "Dwg_TABLE_Cell *""'"); 
  }
  arg2 = (Dwg_TABLE_Cell *)(argp2);
  if (arg1) (arg1)->cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_Cell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_cells_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_TABLE_Cell *) ((arg1)->cells);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_table_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_table_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_table_overrides_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_table_overrides_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_table_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_table_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_table_overrides_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_table_overrides);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_table_flag_override_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_table_flag_override_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_table_flag_override_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_table_flag_override_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->table_flag_override = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_table_flag_override_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_table_flag_override_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->table_flag_override);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_suppressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_suppressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_suppressed_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_suppressed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->title_suppressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_suppressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_suppressed_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->title_suppressed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_suppressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_suppressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_suppressed_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_suppressed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->header_suppressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_suppressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_suppressed_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->header_suppressed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_flow_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_flow_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_flow_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_flow_direction_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flow_direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_flow_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_flow_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flow_direction);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_horiz_cell_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_horiz_cell_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_horiz_cell_margin_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_horiz_cell_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_cell_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_horiz_cell_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_horiz_cell_margin_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_cell_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_vert_cell_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_vert_cell_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_vert_cell_margin_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_vert_cell_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->vert_cell_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_vert_cell_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_vert_cell_margin_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->vert_cell_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_row_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_row_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_row_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_row_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_row_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_row_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_row_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_row_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_row_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_fill_none_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_fill_none_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_fill_none_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_row_fill_none_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->title_row_fill_none = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_fill_none_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_fill_none_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->title_row_fill_none);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_fill_none_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_fill_none_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_fill_none_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_row_fill_none_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->header_row_fill_none = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_fill_none_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_fill_none_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->header_row_fill_none);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_fill_none_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_fill_none_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_fill_none_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_row_fill_none_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->data_row_fill_none = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_fill_none_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_fill_none_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->data_row_fill_none);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_fill_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_row_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_row_fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_fill_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_row_fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_fill_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_row_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_row_fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_fill_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_row_fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_fill_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_row_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_row_fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_fill_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_row_fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_row_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_row_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_row_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_row_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_row_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_row_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_row_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_row_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_row_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_text_style_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->title_text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_text_style_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->title_text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_text_style_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->header_text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_text_style_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->header_text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_text_style_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->data_text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_text_style_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->data_text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_height_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_row_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->title_row_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_height_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->title_row_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_height_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_row_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->header_row_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_height_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->header_row_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_height_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_row_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->data_row_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_height_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->data_row_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_color_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_border_color_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_color_overrides_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_border_color_overrides_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_border_color_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_color_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_color_overrides_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_border_color_overrides);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_color_overrides_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_border_color_overrides_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_color_overrides_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_border_color_overrides_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->border_color_overrides_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_color_overrides_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_color_overrides_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->border_color_overrides_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_top_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_horiz_top_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_horiz_top_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_horiz_top_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_horiz_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_horiz_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_bottom_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_horiz_bottom_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_horiz_bottom_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_left_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_vert_left_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_vert_left_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_vert_left_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_vert_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_vert_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_vert_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_right_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_vert_right_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->title_vert_right_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->title_vert_right_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_top_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_horiz_top_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_horiz_top_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_horiz_top_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_horiz_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_horiz_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_bottom_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_horiz_bottom_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_horiz_bottom_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_left_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_vert_left_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_vert_left_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_vert_left_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_vert_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_vert_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_vert_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_right_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_vert_right_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->header_vert_right_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->header_vert_right_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_top_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_horiz_top_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_horiz_top_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_horiz_top_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_horiz_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_horiz_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_bottom_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_horiz_bottom_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_horiz_bottom_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_left_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_vert_left_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_vert_left_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_vert_left_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_ins_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_vert_ins_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_vert_ins_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_vert_ins_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_right_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_color_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_vert_right_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->data_vert_right_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_color_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->data_vert_right_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_lineweight_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_border_lineweight_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_lineweight_overrides_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_border_lineweight_overrides_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_border_lineweight_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_lineweight_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_lineweight_overrides_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_border_lineweight_overrides);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_lineweight_overrides_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_border_lineweight_overrides_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_lineweight_overrides_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_border_lineweight_overrides_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->border_lineweight_overrides_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_lineweight_overrides_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_lineweight_overrides_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->border_lineweight_overrides_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_top_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_top_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_top_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_top_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_bottom_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_bottom_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_bottom_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_left_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_left_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_left_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_left_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_right_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_right_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_right_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_right_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_top_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_top_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_top_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_top_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_bottom_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_bottom_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_bottom_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_left_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_left_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_left_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_left_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_right_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_right_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_right_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_right_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_top_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_top_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_top_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_top_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_bottom_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_bottom_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_bottom_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_left_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_left_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_left_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_left_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_ins_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_ins_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_ins_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_ins_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_right_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_linewt_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_right_linewt_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_right_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_linewt_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_right_linewt);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_visibility_overrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_border_visibility_overrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_visibility_overrides_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_border_visibility_overrides_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_border_visibility_overrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_border_visibility_overrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_border_visibility_overrides_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_border_visibility_overrides);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_visibility_overrides_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_border_visibility_overrides_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_visibility_overrides_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_border_visibility_overrides_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->border_visibility_overrides_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_border_visibility_overrides_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_border_visibility_overrides_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->border_visibility_overrides_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_top_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_top_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_top_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_top_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_top_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_top_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_horiz_bottom_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_horiz_bottom_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_horiz_bottom_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_horiz_bottom_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_horiz_bottom_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_left_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_left_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_left_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_left_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_left_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_left_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_vert_right_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_title_vert_right_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->title_vert_right_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_vert_right_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_vert_right_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->title_vert_right_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_top_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_top_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_top_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_top_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_top_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_top_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_horiz_bottom_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_horiz_bottom_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_horiz_bottom_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_horiz_bottom_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_horiz_bottom_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_left_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_left_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_left_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_left_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_left_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_left_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_vert_right_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_header_vert_right_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->header_vert_right_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_vert_right_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_vert_right_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->header_vert_right_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_top_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_top_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_top_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_top_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_top_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_top_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_horiz_bottom_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_horiz_bottom_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_horiz_bottom_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_horiz_bottom_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_horiz_bottom_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_left_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_left_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_left_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_left_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_left_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_left_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_ins_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_ins_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_ins_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_ins_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_ins_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_ins_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_vert_right_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_visibility_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_data_vert_right_visibility_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->data_vert_right_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_vert_right_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_vert_right_visibility_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->data_vert_right_visibility);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_block_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_block_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_block_header_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_block_header_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_header = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_block_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_block_header_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->block_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_first_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_first_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_first_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_first_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->first_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_first_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_first_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->first_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_last_attrib_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_last_attrib_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_last_attrib_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_last_attrib_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->last_attrib = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_last_attrib_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_last_attrib_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->last_attrib);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_attribs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_attribs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_attribs_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_attribs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->attribs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_attribs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_attribs_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H *) ((arg1)->attribs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_seqend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_seqend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_seqend_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_seqend_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->seqend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_seqend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_seqend_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->seqend);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_style_override_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_title_row_style_override_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_style_override_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_title_row_style_override_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->title_row_style_override = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_title_row_style_override_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_title_row_style_override_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->title_row_style_override);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_style_override_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_header_row_style_override_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_style_override_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_header_row_style_override_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->header_row_style_override = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_header_row_style_override_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_header_row_style_override_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->header_row_style_override);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_style_override_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_data_row_style_override_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_style_override_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_data_row_style_override_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->data_row_style_override = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_data_row_style_override_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_data_row_style_override_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->data_row_style_override);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_unknown_bs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bs_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_unknown_bs_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->unknown_bs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_unknown_bs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_unknown_bs_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->unknown_bs);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_hor_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_hor_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_hor_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_hor_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->hor_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_hor_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_hor_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->hor_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_break_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_has_break_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_break_data_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_has_break_data_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->has_break_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_has_break_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_has_break_data_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->has_break_data);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_break_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->break_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->break_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_flow_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_flow_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_flow_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_break_flow_direction_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->break_flow_direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_flow_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_flow_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->break_flow_direction);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_break_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->break_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->break_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_unknown1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_unknown1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_unknown1_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_break_unknown1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->break_unknown1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_unknown1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_unknown1_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->break_unknown1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_unknown2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_unknown2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_unknown2_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_break_unknown2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->break_unknown2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_unknown2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_unknown2_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->break_unknown2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_break_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_break_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_break_heights_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_break_heights_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_break_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_break_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_break_heights_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_break_heights);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_TABLE_BreakHeight *arg2 = (Dwg_TABLE_BreakHeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_heights_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_BreakHeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_break_heights_set" "', argument " "2"" of type '" "Dwg_TABLE_BreakHeight *""'"); 
  }
  arg2 = (Dwg_TABLE_BreakHeight *)(argp2);
  if (arg1) (arg1)->break_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_BreakHeight *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_heights_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_TABLE_BreakHeight *) ((arg1)->break_heights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_BreakHeight, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_break_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_num_break_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_break_rows_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_TABLE_num_break_rows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_break_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_num_break_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_num_break_rows_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_break_rows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  Dwg_TABLE_BreakRow *arg2 = (Dwg_TABLE_BreakRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_TABLE_break_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_rows_set" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_BreakRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_TABLE_break_rows_set" "', argument " "2"" of type '" "Dwg_TABLE_BreakRow *""'"); 
  }
  arg2 = (Dwg_TABLE_BreakRow *)(argp2);
  if (arg1) (arg1)->break_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_TABLE_break_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_BreakRow *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_TABLE_break_rows_get" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  result = (Dwg_TABLE_BreakRow *) ((arg1)->break_rows);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_BreakRow, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_TABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_TABLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_TABLE *)calloc(1, sizeof(struct _dwg_entity_TABLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_TABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_TABLE *arg1 = (struct _dwg_entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_TABLE" "', argument " "1"" of type '" "struct _dwg_entity_TABLE *""'"); 
  }
  arg1 = (struct _dwg_entity_TABLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_TABLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_TABLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_TABLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  struct _dwg_object_TABLESTYLE *arg2 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_CellStyle_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_CellStyle_parent_set" "', argument " "2"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg2 = (struct _dwg_object_TABLESTYLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_TABLESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  result = (struct _dwg_object_TABLESTYLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_CellStyle_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_id_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_CellStyle_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_id_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_CellStyle_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_type_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_CellStyle_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_type_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  result = (BITCODE_BL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_CellStyle_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_name_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_CellStyle_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_name_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_cellstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  struct _dwg_CellStyle *arg2 = (struct _dwg_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_CellStyle_cellstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_cellstyle_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_CellStyle_cellstyle_set" "', argument " "2"" of type '" "struct _dwg_CellStyle *""'"); 
  }
  arg2 = (struct _dwg_CellStyle *)(argp2);
  if (arg1) (arg1)->cellstyle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_CellStyle_cellstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_CellStyle_cellstyle_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  result = (struct _dwg_CellStyle *)& ((arg1)->cellstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLESTYLE_CellStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLESTYLE_CellStyle", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLESTYLE_CellStyle *)calloc(1, sizeof(struct _dwg_TABLESTYLE_CellStyle));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLESTYLE_CellStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_CellStyle *arg1 = (struct _dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLESTYLE_CellStyle" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_CellStyle *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLESTYLE_CellStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLESTYLE_CellStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_border_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_linewt_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_border_linewt_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_linewt_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  result = (BITCODE_BSd) ((arg1)->linewt);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_visible_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_border_visible_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_visible_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_border_visible_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->visible = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_visible_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_visible_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  result = (BITCODE_B) ((arg1)->visible);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_border_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_color_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_border_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_border_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_border_color_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLESTYLE_border(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLESTYLE_border", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLESTYLE_border *)calloc(1, sizeof(struct _dwg_TABLESTYLE_border));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_border, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLESTYLE_border(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_border *arg1 = (struct _dwg_TABLESTYLE_border *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_border, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLESTYLE_border" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_border *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_border *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLESTYLE_border_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLESTYLE_border, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLESTYLE_border_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  struct _dwg_object_TABLESTYLE *arg2 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_parent_set" "', argument " "2"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg2 = (struct _dwg_object_TABLESTYLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_TABLESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (struct _dwg_object_TABLESTYLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_style_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_style_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_height_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_height_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_text_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_alignment_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_text_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_alignment_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_text_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_color_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_text_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->text_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_text_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_text_color_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->text_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_fill_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_fill_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_fill_color_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_fill_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->fill_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_fill_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_fill_color_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->fill_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_has_bgcolor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_has_bgcolor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_has_bgcolor_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_has_bgcolor_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_bgcolor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_has_bgcolor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_has_bgcolor_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_B) ((arg1)->has_bgcolor);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_num_borders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_num_borders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_num_borders_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_num_borders_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_borders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_num_borders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_num_borders_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_borders);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_borders_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  Dwg_TABLESTYLE_border *arg2 = (Dwg_TABLESTYLE_border *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_borders_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_borders_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLESTYLE_border, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_borders_set" "', argument " "2"" of type '" "Dwg_TABLESTYLE_border *""'"); 
  }
  arg2 = (Dwg_TABLESTYLE_border *)(argp2);
  if (arg1) (arg1)->borders = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_borders_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLESTYLE_border *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_borders_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (Dwg_TABLESTYLE_border *) ((arg1)->borders);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_border, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_data_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_data_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_data_type_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_data_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->data_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_data_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_data_type_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_BL) ((arg1)->data_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_unit_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_unit_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_unit_type_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLESTYLE_rowstyles_unit_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unit_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_unit_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_unit_type_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_BL) ((arg1)->unit_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_format_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  BITCODE_TU arg2 = (BITCODE_TU) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLESTYLE_rowstyles_format_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_format_string_set" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLESTYLE_rowstyles_format_string_set" "', argument " "2"" of type '" "BITCODE_TU""'"); 
  }
  arg2 = (BITCODE_TU)(argp2);
  if (arg1) (arg1)->format_string = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLESTYLE_rowstyles_format_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TU result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLESTYLE_rowstyles_format_string_get" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  result = (BITCODE_TU) ((arg1)->format_string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLESTYLE_rowstyles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLESTYLE_rowstyles", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLESTYLE_rowstyles *)calloc(1, sizeof(struct _dwg_TABLESTYLE_rowstyles));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLESTYLE_rowstyles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLESTYLE_rowstyles *arg1 = (struct _dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLESTYLE_rowstyles" "', argument " "1"" of type '" "struct _dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg1 = (struct _dwg_TABLESTYLE_rowstyles *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLESTYLE_rowstyles_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLESTYLE_rowstyles_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_name_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_name_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_flags_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_flags_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_flow_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_flow_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_flow_direction_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_flow_direction_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flow_direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_flow_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_flow_direction_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flow_direction);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_horiz_cell_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_horiz_cell_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_horiz_cell_margin_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_horiz_cell_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horiz_cell_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_horiz_cell_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_horiz_cell_margin_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->horiz_cell_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_vert_cell_margin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_vert_cell_margin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_vert_cell_margin_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_vert_cell_margin_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->vert_cell_margin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_vert_cell_margin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_vert_cell_margin_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->vert_cell_margin);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_is_title_suppressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_is_title_suppressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_is_title_suppressed_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_is_title_suppressed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_title_suppressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_is_title_suppressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_is_title_suppressed_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_title_suppressed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_is_header_suppressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_is_header_suppressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_is_header_suppressed_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_is_header_suppressed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_header_suppressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_is_header_suppressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_is_header_suppressed_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_header_suppressed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_rc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_unknown_rc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_rc_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_unknown_rc_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_rc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_rc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_rc_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_rc);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_unknown_bl1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl1_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl1_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_unknown_bl2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl2_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl2_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_cellstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_cellstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_cellstyle_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_cellstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->cellstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_cellstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_cellstyle_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->cellstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_sty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  Dwg_TABLESTYLE_CellStyle *arg2 = (Dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_sty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_sty_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_sty_set" "', argument " "2"" of type '" "Dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg2 = (Dwg_TABLESTYLE_CellStyle *)(argp2);
  if (arg1) (arg1)->sty = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_sty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLESTYLE_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_sty_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (Dwg_TABLESTYLE_CellStyle *)& ((arg1)->sty);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_numoverrides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_numoverrides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_numoverrides_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_numoverrides_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numoverrides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_numoverrides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_numoverrides_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->numoverrides);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_unknown_bl3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl3_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl3_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_unknown_bl3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_unknown_bl3_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_ovr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  Dwg_TABLESTYLE_CellStyle *arg2 = (Dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_ovr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_ovr_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_ovr_set" "', argument " "2"" of type '" "Dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg2 = (Dwg_TABLESTYLE_CellStyle *)(argp2);
  if (arg1) (arg1)->ovr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_ovr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLESTYLE_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_ovr_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (Dwg_TABLESTYLE_CellStyle *)& ((arg1)->ovr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_num_rowstyles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_num_rowstyles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_num_rowstyles_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLESTYLE_num_rowstyles_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_rowstyles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_num_rowstyles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_num_rowstyles_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_rowstyles);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_rowstyles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  Dwg_TABLESTYLE_rowstyles *arg2 = (Dwg_TABLESTYLE_rowstyles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLESTYLE_rowstyles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_rowstyles_set" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLESTYLE_rowstyles_set" "', argument " "2"" of type '" "Dwg_TABLESTYLE_rowstyles *""'"); 
  }
  arg2 = (Dwg_TABLESTYLE_rowstyles *)(argp2);
  if (arg1) (arg1)->rowstyles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLESTYLE_rowstyles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLESTYLE_rowstyles *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLESTYLE_rowstyles_get" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  result = (Dwg_TABLESTYLE_rowstyles *) ((arg1)->rowstyles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_rowstyles, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_TABLESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_TABLESTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_TABLESTYLE *)calloc(1, sizeof(struct _dwg_object_TABLESTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_TABLESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLESTYLE *arg1 = (struct _dwg_object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_TABLESTYLE" "', argument " "1"" of type '" "struct _dwg_object_TABLESTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_TABLESTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_TABLESTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_TABLESTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CELLSTYLEMAP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CELLSTYLEMAP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_num_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CELLSTYLEMAP_num_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_num_cells_set" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_CELLSTYLEMAP_num_cells_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_num_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_num_cells_get" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cells);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  Dwg_TABLESTYLE_CellStyle *arg2 = (Dwg_TABLESTYLE_CellStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CELLSTYLEMAP_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_cells_set" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CELLSTYLEMAP_cells_set" "', argument " "2"" of type '" "Dwg_TABLESTYLE_CellStyle *""'"); 
  }
  arg2 = (Dwg_TABLESTYLE_CellStyle *)(argp2);
  if (arg1) (arg1)->cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CELLSTYLEMAP_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLESTYLE_CellStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CELLSTYLEMAP_cells_get" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  result = (Dwg_TABLESTYLE_CellStyle *) ((arg1)->cells);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLESTYLE_CellStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_CELLSTYLEMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_CELLSTYLEMAP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_CELLSTYLEMAP *)calloc(1, sizeof(struct _dwg_object_CELLSTYLEMAP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CELLSTYLEMAP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_CELLSTYLEMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CELLSTYLEMAP *arg1 = (struct _dwg_object_CELLSTYLEMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_CELLSTYLEMAP" "', argument " "1"" of type '" "struct _dwg_object_CELLSTYLEMAP *""'"); 
  }
  arg1 = (struct _dwg_object_CELLSTYLEMAP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_CELLSTYLEMAP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_CELLSTYLEMAP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_CELLSTYLEMAP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  struct _dwg_object_TABLEGEOMETRY *arg2 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_parent_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLEGEOMETRY_Cell_parent_set" "', argument " "2"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg2 = (struct _dwg_object_TABLEGEOMETRY *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_TABLEGEOMETRY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_parent_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (struct _dwg_object_TABLEGEOMETRY *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geom_data_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_geom_data_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->geom_data_flag);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_width_w_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_width_w_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_width_w_gap_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLEGEOMETRY_Cell_width_w_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width_w_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_width_w_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_width_w_gap_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (BITCODE_BD) ((arg1)->width_w_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_height_w_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_height_w_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_height_w_gap_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLEGEOMETRY_Cell_height_w_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height_w_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_height_w_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_height_w_gap_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (BITCODE_BD) ((arg1)->height_w_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_tablegeometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_tablegeometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_tablegeometry_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLEGEOMETRY_Cell_tablegeometry_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->tablegeometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_tablegeometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_tablegeometry_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (BITCODE_H) ((arg1)->tablegeometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_num_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_num_geometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_num_geometry_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_TABLEGEOMETRY_Cell_num_geometry_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_num_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_num_geometry_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geometry);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  Dwg_CellContentGeometry *arg2 = (Dwg_CellContentGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_TABLEGEOMETRY_Cell_geometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_geometry_set" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CellContentGeometry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_TABLEGEOMETRY_Cell_geometry_set" "', argument " "2"" of type '" "Dwg_CellContentGeometry *""'"); 
  }
  arg2 = (Dwg_CellContentGeometry *)(argp2);
  if (arg1) (arg1)->geometry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_TABLEGEOMETRY_Cell_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CellContentGeometry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_TABLEGEOMETRY_Cell_geometry_get" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  result = (Dwg_CellContentGeometry *) ((arg1)->geometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CellContentGeometry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_TABLEGEOMETRY_Cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_TABLEGEOMETRY_Cell", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_TABLEGEOMETRY_Cell *)calloc(1, sizeof(struct _dwg_TABLEGEOMETRY_Cell));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_TABLEGEOMETRY_Cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_TABLEGEOMETRY_Cell *arg1 = (struct _dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_TABLEGEOMETRY_Cell" "', argument " "1"" of type '" "struct _dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg1 = (struct _dwg_TABLEGEOMETRY_Cell *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_TABLEGEOMETRY_Cell_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_TABLEGEOMETRY_Cell_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLEGEOMETRY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLEGEOMETRY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_numrows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLEGEOMETRY_numrows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_numrows_set" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLEGEOMETRY_numrows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_numrows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_numrows_get" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numrows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_numcols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLEGEOMETRY_numcols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_numcols_set" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLEGEOMETRY_numcols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numcols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_numcols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_numcols_get" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numcols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_num_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLEGEOMETRY_num_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_num_cells_set" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TABLEGEOMETRY_num_cells_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_num_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_num_cells_get" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cells);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_cells_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  Dwg_TABLEGEOMETRY_Cell *arg2 = (Dwg_TABLEGEOMETRY_Cell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TABLEGEOMETRY_cells_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_cells_set" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TABLEGEOMETRY_cells_set" "', argument " "2"" of type '" "Dwg_TABLEGEOMETRY_Cell *""'"); 
  }
  arg2 = (Dwg_TABLEGEOMETRY_Cell *)(argp2);
  if (arg1) (arg1)->cells = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TABLEGEOMETRY_cells_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLEGEOMETRY_Cell *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TABLEGEOMETRY_cells_get" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  result = (Dwg_TABLEGEOMETRY_Cell *) ((arg1)->cells);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLEGEOMETRY_Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_TABLEGEOMETRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_TABLEGEOMETRY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_TABLEGEOMETRY *)calloc(1, sizeof(struct _dwg_object_TABLEGEOMETRY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLEGEOMETRY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_TABLEGEOMETRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TABLEGEOMETRY *arg1 = (struct _dwg_object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_TABLEGEOMETRY" "', argument " "1"" of type '" "struct _dwg_object_TABLEGEOMETRY *""'"); 
  }
  arg1 = (struct _dwg_object_TABLEGEOMETRY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_TABLEGEOMETRY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_TABLEGEOMETRY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_TABLEGEOMETRY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UNDERLAYDEFINITION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_parent_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UNDERLAYDEFINITION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_parent_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UNDERLAYDEFINITION_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_filename_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UNDERLAYDEFINITION_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_filename_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  result = (BITCODE_TV) ((arg1)->filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UNDERLAYDEFINITION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_name_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UNDERLAYDEFINITION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNDERLAYDEFINITION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNDERLAYDEFINITION_name_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_UNDERLAYDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_UNDERLAYDEFINITION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)calloc(1, sizeof(struct _dwg_abstractobject_UNDERLAYDEFINITION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_UNDERLAYDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_UNDERLAYDEFINITION *arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_UNDERLAYDEFINITION" "', argument " "1"" of type '" "struct _dwg_abstractobject_UNDERLAYDEFINITION *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_UNDERLAYDEFINITION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_UNDERLAYDEFINITION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_UNDERLAYDEFINITION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_parent_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_parent_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_extrusion_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_extrusion_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_scale_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_scale_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_scale_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_angle_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_angle_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_flag_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_flag_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_contrast_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_contrast_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_contrast_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_RC) ((arg1)->contrast);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_fade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_fade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_fade_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_fade_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_fade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_fade_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_RC) ((arg1)->fade);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_num_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_num_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_num_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_num_clip_verts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_num_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_num_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_clip_verts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_clip_verts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->clip_verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_num_clip_inverts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_num_clip_inverts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_num_clip_inverts_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_UNDERLAY_num_clip_inverts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_clip_inverts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_num_clip_inverts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_num_clip_inverts_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_clip_inverts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_clip_inverts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_clip_inverts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_clip_inverts_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_clip_inverts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clip_inverts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_clip_inverts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_clip_inverts_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->clip_inverts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_definition_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNDERLAY_definition_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_definition_id_set" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNDERLAY_definition_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->definition_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNDERLAY_definition_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNDERLAY_definition_id_get" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  result = (BITCODE_H) ((arg1)->definition_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_UNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_UNDERLAY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_abstractentity_UNDERLAY *)calloc(1, sizeof(struct _dwg_abstractentity_UNDERLAY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_UNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractentity_UNDERLAY *arg1 = (struct _dwg_abstractentity_UNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_UNDERLAY" "', argument " "1"" of type '" "struct _dwg_abstractentity_UNDERLAY *""'"); 
  }
  arg1 = (struct _dwg_abstractentity_UNDERLAY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_UNDERLAY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_UNDERLAY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DBCOLOR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *arg1 = (struct _dwg_object_DBCOLOR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DBCOLOR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DBCOLOR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DBCOLOR *""'"); 
  }
  arg1 = (struct _dwg_object_DBCOLOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DBCOLOR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DBCOLOR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *arg1 = (struct _dwg_object_DBCOLOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DBCOLOR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DBCOLOR *""'"); 
  }
  arg1 = (struct _dwg_object_DBCOLOR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DBCOLOR_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *arg1 = (struct _dwg_object_DBCOLOR *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DBCOLOR_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DBCOLOR_color_set" "', argument " "1"" of type '" "struct _dwg_object_DBCOLOR *""'"); 
  }
  arg1 = (struct _dwg_object_DBCOLOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DBCOLOR_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DBCOLOR_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *arg1 = (struct _dwg_object_DBCOLOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DBCOLOR_color_get" "', argument " "1"" of type '" "struct _dwg_object_DBCOLOR *""'"); 
  }
  arg1 = (struct _dwg_object_DBCOLOR *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DBCOLOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DBCOLOR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DBCOLOR *)calloc(1, sizeof(struct _dwg_object_DBCOLOR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DBCOLOR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DBCOLOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DBCOLOR *arg1 = (struct _dwg_object_DBCOLOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DBCOLOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DBCOLOR" "', argument " "1"" of type '" "struct _dwg_object_DBCOLOR *""'"); 
  }
  arg1 = (struct _dwg_object_DBCOLOR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DBCOLOR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DBCOLOR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DBCOLOR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  struct _dwg_object_FIELD *arg2 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FIELD_ChildValue_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_parent_set" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_FIELD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FIELD_ChildValue_parent_set" "', argument " "2"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg2 = (struct _dwg_object_FIELD *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_FIELD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_parent_get" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  result = (struct _dwg_object_FIELD *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_key_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FIELD_ChildValue_key_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_key_set" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FIELD_ChildValue_key_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->key);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->key = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->key = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_key_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_key_get" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  result = (BITCODE_TV) ((arg1)->key);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FIELD_ChildValue_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_value_set" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FIELD_ChildValue_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FIELD_ChildValue_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FIELD_ChildValue_value_get" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_FIELD_ChildValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_FIELD_ChildValue", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_FIELD_ChildValue *)calloc(1, sizeof(struct _dwg_FIELD_ChildValue));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FIELD_ChildValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_FIELD_ChildValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FIELD_ChildValue *arg1 = (struct _dwg_FIELD_ChildValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FIELD_ChildValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_FIELD_ChildValue" "', argument " "1"" of type '" "struct _dwg_FIELD_ChildValue *""'"); 
  }
  arg1 = (struct _dwg_FIELD_ChildValue *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_FIELD_ChildValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_FIELD_ChildValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_FIELD_ChildValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_parent_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_parent_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_id_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_id_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->id);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->id = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->id = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_id_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_TV) ((arg1)->id);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_code_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_code_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->code);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->code = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->code = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_code_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_TV) ((arg1)->code);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_childs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_num_childs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_childs_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_num_childs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_childs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_childs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_childs_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_childs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_childs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_childs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_childs_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_childs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->childs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_childs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_childs_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_H *) ((arg1)->childs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_objects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_num_objects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_objects_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_num_objects_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_objects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_objects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_objects_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_objects);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_objects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_objects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_objects_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_objects_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->objects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_objects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_objects_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_H *) ((arg1)->objects);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_format_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_format_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_format_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->format);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->format = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->format = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_format_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_TV) ((arg1)->format);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_evaluation_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_option_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_evaluation_option_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->evaluation_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_option_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->evaluation_option);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_filing_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_filing_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_filing_option_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_filing_option_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->filing_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_filing_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_filing_option_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->filing_option);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_field_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_field_state_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_field_state_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_field_state_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->field_state = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_field_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_field_state_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->field_state);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_evaluation_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_status_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_evaluation_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->evaluation_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_status_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->evaluation_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_error_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_evaluation_error_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_error_code_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_evaluation_error_code_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->evaluation_error_code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_error_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_error_code_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->evaluation_error_code);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_error_msg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_evaluation_error_msg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_error_msg_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_evaluation_error_msg_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->evaluation_error_msg);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->evaluation_error_msg = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->evaluation_error_msg = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_evaluation_error_msg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_evaluation_error_msg_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_TV) ((arg1)->evaluation_error_msg);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_value_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_string_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_value_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->value_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->value_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->value_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_string_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_TV) ((arg1)->value_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_string_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_value_string_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_string_length_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_value_string_length_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->value_string_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_value_string_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_value_string_length_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->value_string_length);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_childval_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_num_childval_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_childval_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELD_num_childval_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_childval = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_num_childval_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_num_childval_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_childval);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_childval_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  Dwg_FIELD_ChildValue *arg2 = (Dwg_FIELD_ChildValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELD_childval_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_childval_set" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FIELD_ChildValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELD_childval_set" "', argument " "2"" of type '" "Dwg_FIELD_ChildValue *""'"); 
  }
  arg2 = (Dwg_FIELD_ChildValue *)(argp2);
  if (arg1) (arg1)->childval = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELD_childval_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FIELD_ChildValue *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELD_childval_get" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  result = (Dwg_FIELD_ChildValue *) ((arg1)->childval);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FIELD_ChildValue, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_FIELD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_FIELD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_FIELD *)calloc(1, sizeof(struct _dwg_object_FIELD));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_FIELD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELD *arg1 = (struct _dwg_object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_FIELD" "', argument " "1"" of type '" "struct _dwg_object_FIELD *""'"); 
  }
  arg1 = (struct _dwg_object_FIELD *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_FIELD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_FIELD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_FIELD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELDLIST_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_parent_set" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELDLIST_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_parent_get" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_num_fields_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELDLIST_num_fields_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_num_fields_set" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELDLIST_num_fields_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_fields = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_num_fields_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_num_fields_get" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_fields);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELDLIST_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_unknown_set" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FIELDLIST_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_unknown_get" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_fields_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FIELDLIST_fields_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_fields_set" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FIELDLIST_fields_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->fields = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FIELDLIST_fields_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FIELDLIST_fields_get" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  result = (BITCODE_H *) ((arg1)->fields);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_FIELDLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_FIELDLIST", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_FIELDLIST *)calloc(1, sizeof(struct _dwg_object_FIELDLIST));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELDLIST, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_FIELDLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FIELDLIST *arg1 = (struct _dwg_object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FIELDLIST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_FIELDLIST" "', argument " "1"" of type '" "struct _dwg_object_FIELDLIST *""'"); 
  }
  arg1 = (struct _dwg_object_FIELDLIST *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_FIELDLIST_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_FIELDLIST, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_FIELDLIST_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshpt_source_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *arg1 = (struct _dwg_GEODATA_meshpt *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GEODATA_meshpt_source_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshpt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshpt_source_pt_set" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshpt *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshpt *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_GEODATA_meshpt_source_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->source_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshpt_source_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *arg1 = (struct _dwg_GEODATA_meshpt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshpt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshpt_source_pt_get" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshpt *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshpt *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->source_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshpt_dest_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *arg1 = (struct _dwg_GEODATA_meshpt *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GEODATA_meshpt_dest_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshpt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshpt_dest_pt_set" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshpt *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshpt *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_GEODATA_meshpt_dest_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->dest_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshpt_dest_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *arg1 = (struct _dwg_GEODATA_meshpt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshpt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshpt_dest_pt_get" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshpt *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshpt *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->dest_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_GEODATA_meshpt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_GEODATA_meshpt", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_GEODATA_meshpt *)calloc(1, sizeof(struct _dwg_GEODATA_meshpt));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GEODATA_meshpt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_GEODATA_meshpt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshpt *arg1 = (struct _dwg_GEODATA_meshpt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshpt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_GEODATA_meshpt" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshpt *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshpt *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_GEODATA_meshpt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_GEODATA_meshpt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_GEODATA_meshpt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GEODATA_meshface_face1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face1_set" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GEODATA_meshface_face1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face1_get" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  result = (BITCODE_BL) ((arg1)->face1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GEODATA_meshface_face2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face2_set" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GEODATA_meshface_face2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face2_get" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  result = (BITCODE_BL) ((arg1)->face2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_GEODATA_meshface_face3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face3_set" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_GEODATA_meshface_face3_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_GEODATA_meshface_face3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_GEODATA_meshface_face3_get" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  result = (BITCODE_BL) ((arg1)->face3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_GEODATA_meshface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_GEODATA_meshface", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_GEODATA_meshface *)calloc(1, sizeof(struct _dwg_GEODATA_meshface));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GEODATA_meshface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_GEODATA_meshface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_GEODATA_meshface *arg1 = (struct _dwg_GEODATA_meshface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_GEODATA_meshface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_GEODATA_meshface" "', argument " "1"" of type '" "struct _dwg_GEODATA_meshface *""'"); 
  }
  arg1 = (struct _dwg_GEODATA_meshface *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_GEODATA_meshface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_GEODATA_meshface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_GEODATA_meshface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_host_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_host_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_host_block_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_host_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->host_block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_host_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_host_block_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_H) ((arg1)->host_block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_coord_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_type_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_coord_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->coord_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_type_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->coord_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_design_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_design_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_design_pt_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_design_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->design_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_design_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_design_pt_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->design_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_ref_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_ref_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_ref_pt_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_ref_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ref_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_ref_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_ref_pt_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ref_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_obs_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_obs_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_obs_pt_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_obs_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->obs_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_obs_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_obs_pt_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->obs_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_scale_vec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_scale_vec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_scale_vec_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_scale_vec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_scale_vec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_scale_vec_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unit_scale_horiz_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_unit_scale_horiz_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unit_scale_horiz_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_unit_scale_horiz_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit_scale_horiz = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unit_scale_horiz_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unit_scale_horiz_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit_scale_horiz);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_units_value_horiz_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_units_value_horiz_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_units_value_horiz_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_units_value_horiz_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->units_value_horiz = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_units_value_horiz_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_units_value_horiz_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->units_value_horiz);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unit_scale_vert_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_unit_scale_vert_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unit_scale_vert_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_unit_scale_vert_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unit_scale_vert = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unit_scale_vert_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unit_scale_vert_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->unit_scale_vert);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_units_value_vert_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_units_value_vert_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_units_value_vert_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_units_value_vert_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->units_value_vert = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_units_value_vert_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_units_value_vert_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->units_value_vert);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_up_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_up_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_up_dir_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_up_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->up_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_up_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_up_dir_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->up_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_north_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_north_dir_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->north_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->north_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_scale_est_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_scale_est_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_scale_est_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_scale_est_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->scale_est = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_scale_est_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_scale_est_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->scale_est);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_user_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_user_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_user_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_user_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->user_scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_user_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_user_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->user_scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_do_sea_level_corr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_do_sea_level_corr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_do_sea_level_corr_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_do_sea_level_corr_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->do_sea_level_corr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_do_sea_level_corr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_do_sea_level_corr_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_B) ((arg1)->do_sea_level_corr);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_sea_level_elev_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_sea_level_elev_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_sea_level_elev_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_sea_level_elev_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sea_level_elev = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_sea_level_elev_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_sea_level_elev_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->sea_level_elev);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_proj_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_coord_proj_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_proj_radius_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_coord_proj_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->coord_proj_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_proj_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_proj_radius_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->coord_proj_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_def_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_coord_system_def_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_def_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_coord_system_def_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->coord_system_def);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->coord_system_def = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->coord_system_def = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_def_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_def_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->coord_system_def);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geo_rss_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_geo_rss_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geo_rss_tag_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_geo_rss_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->geo_rss_tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->geo_rss_tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->geo_rss_tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geo_rss_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geo_rss_tag_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->geo_rss_tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_datum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_coord_system_datum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_datum_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_coord_system_datum_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->coord_system_datum);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->coord_system_datum = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->coord_system_datum = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_datum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_datum_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->coord_system_datum);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_wkt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_coord_system_wkt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_wkt_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_coord_system_wkt_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->coord_system_wkt);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->coord_system_wkt = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->coord_system_wkt = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_coord_system_wkt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_coord_system_wkt_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->coord_system_wkt);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_from_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_observation_from_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_from_tag_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_observation_from_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->observation_from_tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->observation_from_tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->observation_from_tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_from_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_from_tag_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->observation_from_tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_to_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_observation_to_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_to_tag_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_observation_to_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->observation_to_tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->observation_to_tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->observation_to_tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_to_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_to_tag_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->observation_to_tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_coverage_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_observation_coverage_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_coverage_tag_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_observation_coverage_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->observation_coverage_tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->observation_coverage_tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->observation_coverage_tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_observation_coverage_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_observation_coverage_tag_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_TV) ((arg1)->observation_coverage_tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_num_geomesh_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_num_geomesh_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_num_geomesh_pts_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_num_geomesh_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geomesh_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_num_geomesh_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_num_geomesh_pts_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geomesh_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geomesh_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  Dwg_GEODATA_meshpt *arg2 = (Dwg_GEODATA_meshpt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_geomesh_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geomesh_pts_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_GEODATA_meshpt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_geomesh_pts_set" "', argument " "2"" of type '" "Dwg_GEODATA_meshpt *""'"); 
  }
  arg2 = (Dwg_GEODATA_meshpt *)(argp2);
  if (arg1) (arg1)->geomesh_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geomesh_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_GEODATA_meshpt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geomesh_pts_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (Dwg_GEODATA_meshpt *) ((arg1)->geomesh_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GEODATA_meshpt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_num_geomesh_faces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_num_geomesh_faces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_num_geomesh_faces_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_num_geomesh_faces_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geomesh_faces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_num_geomesh_faces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_num_geomesh_faces_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geomesh_faces);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geomesh_faces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  Dwg_GEODATA_meshface *arg2 = (Dwg_GEODATA_meshface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_geomesh_faces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geomesh_faces_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_GEODATA_meshface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_geomesh_faces_set" "', argument " "2"" of type '" "Dwg_GEODATA_meshface *""'"); 
  }
  arg2 = (Dwg_GEODATA_meshface *)(argp2);
  if (arg1) (arg1)->geomesh_faces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_geomesh_faces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_GEODATA_meshface *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_geomesh_faces_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (Dwg_GEODATA_meshface *) ((arg1)->geomesh_faces);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_GEODATA_meshface, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_has_civil_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_has_civil_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_has_civil_data_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_has_civil_data_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_civil_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_has_civil_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_has_civil_data_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_B) ((arg1)->has_civil_data);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_obsolete_false_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_obsolete_false_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_obsolete_false_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_obsolete_false_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->obsolete_false = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_obsolete_false_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_obsolete_false_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_B) ((arg1)->obsolete_false);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_ref_pt2d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_ref_pt2d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_ref_pt2d_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_ref_pt2d_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->ref_pt2d = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_ref_pt2d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_ref_pt2d_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->ref_pt2d);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_zero1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_zero1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_zero1_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_zero1_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->zero1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_zero1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_zero1_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->zero1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_zero2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_zero2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_zero2_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEODATA_zero2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->zero2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_zero2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_zero2_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->zero2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_unknown1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown1_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_unknown1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown1_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_unknown2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown2_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_unknown2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown2_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_unknown_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown_b_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_unknown_b_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_unknown_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_unknown_b_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_angle_deg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_north_dir_angle_deg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_angle_deg_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_north_dir_angle_deg_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->north_dir_angle_deg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_angle_deg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_angle_deg_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->north_dir_angle_deg);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_angle_rad_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEODATA_north_dir_angle_rad_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_angle_rad_set" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEODATA_north_dir_angle_rad_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->north_dir_angle_rad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEODATA_north_dir_angle_rad_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEODATA_north_dir_angle_rad_get" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->north_dir_angle_rad);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_GEODATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_GEODATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_GEODATA *)calloc(1, sizeof(struct _dwg_object_GEODATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GEODATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_GEODATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEODATA *arg1 = (struct _dwg_object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEODATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_GEODATA" "', argument " "1"" of type '" "struct _dwg_object_GEODATA *""'"); 
  }
  arg1 = (struct _dwg_object_GEODATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_GEODATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_GEODATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_GEODATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IDBUFFER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IDBUFFER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IDBUFFER_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_unknown_set" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IDBUFFER_unknown_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_unknown_get" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_num_obj_ids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IDBUFFER_num_obj_ids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_num_obj_ids_set" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IDBUFFER_num_obj_ids_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_obj_ids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_num_obj_ids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_num_obj_ids_get" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_obj_ids);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_obj_ids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IDBUFFER_obj_ids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_obj_ids_set" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IDBUFFER_obj_ids_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->obj_ids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IDBUFFER_obj_ids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IDBUFFER_obj_ids_get" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  result = (BITCODE_H *) ((arg1)->obj_ids);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_IDBUFFER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_IDBUFFER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_IDBUFFER *)calloc(1, sizeof(struct _dwg_object_IDBUFFER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IDBUFFER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_IDBUFFER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IDBUFFER *arg1 = (struct _dwg_object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IDBUFFER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_IDBUFFER" "', argument " "1"" of type '" "struct _dwg_object_IDBUFFER *""'"); 
  }
  arg1 = (struct _dwg_object_IDBUFFER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_IDBUFFER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_IDBUFFER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_IDBUFFER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_pt0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_pt0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_pt0_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_pt0_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_pt0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_pt0_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_uvec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_uvec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_uvec_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_uvec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->uvec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_uvec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_uvec_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->uvec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_vvec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_vvec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_vvec_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_vvec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vvec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_vvec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_vvec_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vvec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_image_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_image_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_image_size_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_image_size_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->image_size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_image_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_image_size_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->image_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_display_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_display_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_display_props_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_display_props_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_display_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_display_props_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clipping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_clipping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clipping_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_clipping_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->clipping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clipping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clipping_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_B) ((arg1)->clipping);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_brightness_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_brightness_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_brightness_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->brightness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_contrast_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_contrast_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_contrast_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->contrast);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_fade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_fade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_fade_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_fade_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_fade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_fade_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->fade);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_clip_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_clip_mode_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->clip_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_B) ((arg1)->clip_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_boundary_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_clip_boundary_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_boundary_type_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_clip_boundary_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->clip_boundary_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_boundary_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_boundary_type_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->clip_boundary_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_num_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_num_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_num_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_IMAGE_num_clip_verts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_num_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_num_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_clip_verts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_clip_verts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->clip_verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_imagedef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_imagedef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_imagedef_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_imagedef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->imagedef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_imagedef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_imagedef_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_H) ((arg1)->imagedef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_imagedefreactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_IMAGE_imagedefreactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_imagedefreactor_set" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_IMAGE_imagedefreactor_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->imagedefreactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_IMAGE_imagedefreactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_IMAGE_imagedefreactor_get" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  result = (BITCODE_H) ((arg1)->imagedefreactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_IMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_IMAGE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_IMAGE *)calloc(1, sizeof(struct _dwg_entity_IMAGE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_IMAGE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_IMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_IMAGE *arg1 = (struct _dwg_entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_IMAGE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_IMAGE" "', argument " "1"" of type '" "struct _dwg_entity_IMAGE *""'"); 
  }
  arg1 = (struct _dwg_entity_IMAGE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_IMAGE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_IMAGE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_IMAGE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_parent_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGEDEF_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_parent_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGEDEF_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_image_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_image_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_image_size_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGEDEF_image_size_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->image_size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_image_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_image_size_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->image_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_file_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_file_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_file_path_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGEDEF_file_path_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->file_path);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->file_path = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->file_path = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_file_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_file_path_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->file_path);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_is_loaded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_is_loaded_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_is_loaded_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGEDEF_is_loaded_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_loaded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_is_loaded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_is_loaded_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->is_loaded);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_resunits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_resunits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_resunits_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGEDEF_resunits_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->resunits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_resunits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_resunits_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_RC) ((arg1)->resunits);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_pixel_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_pixel_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_pixel_size_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGEDEF_pixel_size_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pixel_size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_pixel_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_pixel_size_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->pixel_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_IMAGEDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_IMAGEDEF", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_IMAGEDEF *)calloc(1, sizeof(struct _dwg_object_IMAGEDEF));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_IMAGEDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF *arg1 = (struct _dwg_object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_IMAGEDEF" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_IMAGEDEF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_IMAGEDEF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_IMAGEDEF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_REACTOR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_REACTOR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_REACTOR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_REACTOR_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGEDEF_REACTOR_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGEDEF_REACTOR_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGEDEF_REACTOR_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_IMAGEDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_IMAGEDEF_REACTOR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_IMAGEDEF_REACTOR *)calloc(1, sizeof(struct _dwg_object_IMAGEDEF_REACTOR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_IMAGEDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGEDEF_REACTOR *arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_IMAGEDEF_REACTOR" "', argument " "1"" of type '" "struct _dwg_object_IMAGEDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGEDEF_REACTOR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_IMAGEDEF_REACTOR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_IMAGEDEF_REACTOR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_INDEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *arg1 = (struct _dwg_object_INDEX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_INDEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_INDEX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_INDEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_INDEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *arg1 = (struct _dwg_object_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_INDEX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_INDEX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_INDEX_last_updated_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *arg1 = (struct _dwg_object_INDEX *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_INDEX_last_updated_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_INDEX_last_updated_set" "', argument " "1"" of type '" "struct _dwg_object_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_INDEX_last_updated_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->last_updated = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_INDEX_last_updated_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *arg1 = (struct _dwg_object_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_INDEX_last_updated_get" "', argument " "1"" of type '" "struct _dwg_object_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_INDEX *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->last_updated);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_INDEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_INDEX *)calloc(1, sizeof(struct _dwg_object_INDEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_INDEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_INDEX *arg1 = (struct _dwg_object_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_INDEX" "', argument " "1"" of type '" "struct _dwg_object_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_INDEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_INDEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_INDEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_INDEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  struct _dwg_object_LAYER_INDEX *arg2 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LAYER_entry_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_parent_set" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYER_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LAYER_entry_parent_set" "', argument " "2"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg2 = (struct _dwg_object_LAYER_INDEX *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_LAYER_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_parent_get" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  result = (struct _dwg_object_LAYER_INDEX *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_numlayers_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LAYER_entry_numlayers_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_numlayers_set" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_LAYER_entry_numlayers_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numlayers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_numlayers_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_numlayers_get" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  result = (BITCODE_BL) ((arg1)->numlayers);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LAYER_entry_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_name_set" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LAYER_entry_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_name_get" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LAYER_entry_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_handle_set" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LAYER_entry_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LAYER_entry_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LAYER_entry_handle_get" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LAYER_entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LAYER_entry", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LAYER_entry *)calloc(1, sizeof(struct _dwg_LAYER_entry));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LAYER_entry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LAYER_entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LAYER_entry *arg1 = (struct _dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LAYER_entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LAYER_entry" "', argument " "1"" of type '" "struct _dwg_LAYER_entry *""'"); 
  }
  arg1 = (struct _dwg_LAYER_entry *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LAYER_entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LAYER_entry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LAYER_entry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_INDEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_INDEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_last_updated_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_INDEX_last_updated_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_last_updated_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_INDEX_last_updated_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->last_updated = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_last_updated_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_last_updated_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->last_updated);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_INDEX_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYER_INDEX_num_entries_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  Dwg_LAYER_entry *arg2 = (Dwg_LAYER_entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYER_INDEX_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_entries_set" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LAYER_entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYER_INDEX_entries_set" "', argument " "2"" of type '" "Dwg_LAYER_entry *""'"); 
  }
  arg2 = (Dwg_LAYER_entry *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYER_INDEX_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LAYER_entry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYER_INDEX_entries_get" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  result = (Dwg_LAYER_entry *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LAYER_entry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LAYER_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LAYER_INDEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LAYER_INDEX *)calloc(1, sizeof(struct _dwg_object_LAYER_INDEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_INDEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LAYER_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYER_INDEX *arg1 = (struct _dwg_object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYER_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LAYER_INDEX" "', argument " "1"" of type '" "struct _dwg_object_LAYER_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_LAYER_INDEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LAYER_INDEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LAYER_INDEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LAYER_INDEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_const_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_const_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_const_width_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_const_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->const_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_const_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_const_width_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->const_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_elevation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_elevation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_elevation_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_elevation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_elevation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_elevation_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_thickness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_points_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_points_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_points_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_points_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_points_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_bulges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_num_bulges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_bulges_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_num_bulges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_bulges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_bulges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_bulges_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_bulges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_bulges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_bulges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_bulges_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_bulges_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->bulges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_bulges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_bulges_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->bulges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_vertexids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_num_vertexids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_vertexids_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_num_vertexids_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_vertexids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_vertexids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_vertexids_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_vertexids);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_vertexids_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_vertexids_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_vertexids_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_vertexids_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->vertexids = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_vertexids_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_vertexids_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->vertexids);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_widths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_num_widths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_widths_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LWPOLYLINE_num_widths_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_widths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_num_widths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_num_widths_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_widths);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_widths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  Dwg_LWPOLYLINE_width *arg2 = (Dwg_LWPOLYLINE_width *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LWPOLYLINE_widths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_widths_set" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LWPOLYLINE_width, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LWPOLYLINE_widths_set" "', argument " "2"" of type '" "Dwg_LWPOLYLINE_width *""'"); 
  }
  arg2 = (Dwg_LWPOLYLINE_width *)(argp2);
  if (arg1) (arg1)->widths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LWPOLYLINE_widths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LWPOLYLINE_width *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LWPOLYLINE_widths_get" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  result = (Dwg_LWPOLYLINE_width *) ((arg1)->widths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LWPOLYLINE_width, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LWPOLYLINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LWPOLYLINE *)calloc(1, sizeof(struct _dwg_entity_LWPOLYLINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LWPOLYLINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LWPOLYLINE *arg1 = (struct _dwg_entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LWPOLYLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LWPOLYLINE" "', argument " "1"" of type '" "struct _dwg_entity_LWPOLYLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_LWPOLYLINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LWPOLYLINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LWPOLYLINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LWPOLYLINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RASTERVARIABLES_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RASTERVARIABLES_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RASTERVARIABLES_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RASTERVARIABLES_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_image_frame_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RASTERVARIABLES_image_frame_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_image_frame_set" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RASTERVARIABLES_image_frame_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->image_frame = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_image_frame_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_image_frame_get" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  result = (BITCODE_BS) ((arg1)->image_frame);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_image_quality_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RASTERVARIABLES_image_quality_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_image_quality_set" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RASTERVARIABLES_image_quality_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->image_quality = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_image_quality_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_image_quality_get" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  result = (BITCODE_BS) ((arg1)->image_quality);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RASTERVARIABLES_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_units_set" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RASTERVARIABLES_units_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RASTERVARIABLES_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RASTERVARIABLES_units_get" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  result = (BITCODE_BS) ((arg1)->units);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RASTERVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RASTERVARIABLES", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RASTERVARIABLES *)calloc(1, sizeof(struct _dwg_object_RASTERVARIABLES));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RASTERVARIABLES, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RASTERVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RASTERVARIABLES *arg1 = (struct _dwg_object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RASTERVARIABLES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RASTERVARIABLES" "', argument " "1"" of type '" "struct _dwg_object_RASTERVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_RASTERVARIABLES *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RASTERVARIABLES_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RASTERVARIABLES, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RASTERVARIABLES_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SCALE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_flag_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SCALE_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_flag_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_name_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SCALE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_name_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_paper_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_paper_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_paper_units_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SCALE_paper_units_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->paper_units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_paper_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_paper_units_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (BITCODE_BD) ((arg1)->paper_units);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_drawing_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_drawing_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_drawing_units_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SCALE_drawing_units_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->drawing_units = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_drawing_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_drawing_units_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (BITCODE_BD) ((arg1)->drawing_units);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_is_unit_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SCALE_is_unit_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_is_unit_scale_set" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SCALE_is_unit_scale_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_unit_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SCALE_is_unit_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SCALE_is_unit_scale_get" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_unit_scale);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SCALE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SCALE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SCALE *)calloc(1, sizeof(struct _dwg_object_SCALE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SCALE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SCALE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SCALE *arg1 = (struct _dwg_object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SCALE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SCALE" "', argument " "1"" of type '" "struct _dwg_object_SCALE *""'"); 
  }
  arg1 = (struct _dwg_object_SCALE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SCALE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SCALE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SCALE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SORTENTSTABLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SORTENTSTABLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_num_ents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SORTENTSTABLE_num_ents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_num_ents_set" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SORTENTSTABLE_num_ents_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_ents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_num_ents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_num_ents_get" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_ents);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_sort_ents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SORTENTSTABLE_sort_ents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_sort_ents_set" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SORTENTSTABLE_sort_ents_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->sort_ents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_sort_ents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_sort_ents_get" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  result = (BITCODE_H *) ((arg1)->sort_ents);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_block_owner_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SORTENTSTABLE_block_owner_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_block_owner_set" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SORTENTSTABLE_block_owner_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block_owner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_block_owner_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_block_owner_get" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->block_owner);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_ents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SORTENTSTABLE_ents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_ents_set" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SORTENTSTABLE_ents_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->ents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SORTENTSTABLE_ents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SORTENTSTABLE_ents_get" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  result = (BITCODE_H *) ((arg1)->ents);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SORTENTSTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SORTENTSTABLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SORTENTSTABLE *)calloc(1, sizeof(struct _dwg_object_SORTENTSTABLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SORTENTSTABLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SORTENTSTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SORTENTSTABLE *arg1 = (struct _dwg_object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SORTENTSTABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SORTENTSTABLE" "', argument " "1"" of type '" "struct _dwg_object_SORTENTSTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_SORTENTSTABLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SORTENTSTABLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SORTENTSTABLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SORTENTSTABLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_num_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_num_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_num_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_num_clip_verts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_num_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_num_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_clip_verts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_clip_verts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->clip_verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_extrusion_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_extrusion_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_origin_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_origin_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_origin_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_display_boundary_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_display_boundary_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_display_boundary_on_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_display_boundary_on_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_boundary_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_display_boundary_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_display_boundary_on_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_boundary_on);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_front_clip_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_front_clip_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_on_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_on_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->front_clip_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_front_clip_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_on_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BS) ((arg1)->front_clip_on);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_front_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_front_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->front_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_front_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_front_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BD) ((arg1)->front_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_back_clip_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_back_clip_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_on_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_on_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->back_clip_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_back_clip_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_on_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BS) ((arg1)->back_clip_on);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_back_clip_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_back_clip_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_z_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_z_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->back_clip_z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_back_clip_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_back_clip_z_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BD) ((arg1)->back_clip_z);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_inverse_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_inverse_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_inverse_transform_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_inverse_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->inverse_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_inverse_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_inverse_transform_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BD *) ((arg1)->inverse_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_FILTER_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_transform_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_FILTER_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_FILTER_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_FILTER_transform_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SPATIAL_FILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SPATIAL_FILTER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SPATIAL_FILTER *)calloc(1, sizeof(struct _dwg_object_SPATIAL_FILTER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_FILTER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SPATIAL_FILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_FILTER *arg1 = (struct _dwg_object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SPATIAL_FILTER" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_FILTER *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_FILTER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SPATIAL_FILTER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SPATIAL_FILTER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SPATIAL_FILTER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_INDEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_last_updated_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_TIMEBLL *arg2 = (BITCODE_TIMEBLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_last_updated_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_last_updated_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_INDEX_last_updated_set" "', argument " "2"" of type '" "BITCODE_TIMEBLL *""'"); 
  }
  arg2 = (BITCODE_TIMEBLL *)(argp2);
  if (arg1) (arg1)->last_updated = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_last_updated_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMEBLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_last_updated_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_TIMEBLL *)& ((arg1)->last_updated);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num1_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num1_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num2_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num2_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num3_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num3_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num3_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num4_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num4_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num4_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num5_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num5_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num5_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num6_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num6_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num6_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num6_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num6 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num6_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num6_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->num6);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_num_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_num_hdls_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_num_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_num_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_hdls);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_INDEX_hdls_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_H *) ((arg1)->hdls);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_bindata_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_bindata_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_size_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bindata_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_bindata_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_size_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->bindata_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_bindata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SPATIAL_INDEX_bindata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_set" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->bindata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SPATIAL_INDEX_bindata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SPATIAL_INDEX_bindata_get" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  result = (BITCODE_TF) ((arg1)->bindata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SPATIAL_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SPATIAL_INDEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SPATIAL_INDEX *)calloc(1, sizeof(struct _dwg_object_SPATIAL_INDEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_INDEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SPATIAL_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SPATIAL_INDEX *arg1 = (struct _dwg_object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SPATIAL_INDEX" "', argument " "1"" of type '" "struct _dwg_object_SPATIAL_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_SPATIAL_INDEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SPATIAL_INDEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SPATIAL_INDEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SPATIAL_INDEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_pt0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_pt0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_pt0_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_pt0_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_pt0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_pt0_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_uvec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_uvec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_uvec_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_uvec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->uvec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_uvec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_uvec_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->uvec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_vvec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_vvec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_vvec_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_vvec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vvec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_vvec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_vvec_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vvec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_image_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_image_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_image_size_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_image_size_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->image_size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_image_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_image_size_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->image_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_display_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_display_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_display_props_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_display_props_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_display_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_display_props_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clipping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_clipping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clipping_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_clipping_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->clipping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clipping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clipping_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_B) ((arg1)->clipping);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_brightness_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_brightness_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_brightness_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_RC) ((arg1)->brightness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_contrast_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_contrast_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_contrast_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_RC) ((arg1)->contrast);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_fade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_fade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_fade_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_fade_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_fade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_fade_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_RC) ((arg1)->fade);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_clip_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_mode_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_clip_mode_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->clip_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_mode_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_B) ((arg1)->clip_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_boundary_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_clip_boundary_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_boundary_type_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_clip_boundary_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->clip_boundary_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_boundary_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_boundary_type_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_BS) ((arg1)->clip_boundary_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_num_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_num_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_num_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_WIPEOUT_num_clip_verts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_num_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_num_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_clip_verts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_clip_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_clip_verts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->clip_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_clip_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_clip_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->clip_verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_imagedef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_imagedef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_imagedef_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_imagedef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->imagedef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_imagedef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_imagedef_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->imagedef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_imagedefreactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_WIPEOUT_imagedefreactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_imagedefreactor_set" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_WIPEOUT_imagedefreactor_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->imagedefreactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_WIPEOUT_imagedefreactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_WIPEOUT_imagedefreactor_get" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  result = (BITCODE_H) ((arg1)->imagedefreactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_WIPEOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_WIPEOUT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_WIPEOUT *)calloc(1, sizeof(struct _dwg_entity_WIPEOUT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_WIPEOUT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_WIPEOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_WIPEOUT *arg1 = (struct _dwg_entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_WIPEOUT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_WIPEOUT" "', argument " "1"" of type '" "struct _dwg_entity_WIPEOUT *""'"); 
  }
  arg1 = (struct _dwg_entity_WIPEOUT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_WIPEOUT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_WIPEOUT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_WIPEOUT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_WIPEOUTVARIABLES_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *arg1 = (struct _dwg_object_WIPEOUTVARIABLES *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_WIPEOUTVARIABLES_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_WIPEOUTVARIABLES_parent_set" "', argument " "1"" of type '" "struct _dwg_object_WIPEOUTVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_WIPEOUTVARIABLES *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_WIPEOUTVARIABLES_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_WIPEOUTVARIABLES_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *arg1 = (struct _dwg_object_WIPEOUTVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_WIPEOUTVARIABLES_parent_get" "', argument " "1"" of type '" "struct _dwg_object_WIPEOUTVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_WIPEOUTVARIABLES *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_WIPEOUTVARIABLES_display_frame_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *arg1 = (struct _dwg_object_WIPEOUTVARIABLES *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_WIPEOUTVARIABLES_display_frame_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_WIPEOUTVARIABLES_display_frame_set" "', argument " "1"" of type '" "struct _dwg_object_WIPEOUTVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_WIPEOUTVARIABLES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_WIPEOUTVARIABLES_display_frame_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_frame = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_WIPEOUTVARIABLES_display_frame_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *arg1 = (struct _dwg_object_WIPEOUTVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_WIPEOUTVARIABLES_display_frame_get" "', argument " "1"" of type '" "struct _dwg_object_WIPEOUTVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_WIPEOUTVARIABLES *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_frame);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_WIPEOUTVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_WIPEOUTVARIABLES", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_WIPEOUTVARIABLES *)calloc(1, sizeof(struct _dwg_object_WIPEOUTVARIABLES));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_WIPEOUTVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_WIPEOUTVARIABLES *arg1 = (struct _dwg_object_WIPEOUTVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_WIPEOUTVARIABLES" "', argument " "1"" of type '" "struct _dwg_object_WIPEOUTVARIABLES *""'"); 
  }
  arg1 = (struct _dwg_object_WIPEOUTVARIABLES *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_WIPEOUTVARIABLES_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_WIPEOUTVARIABLES_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_state_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_state_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_state_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->state = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_state_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->state);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_name_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_name_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_vert_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_vert_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_vert_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_vert_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vert_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_vert_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_vert_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vert_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_top_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_top_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_top_height_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_top_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->top_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_top_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_top_height_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BD) ((arg1)->top_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_bottom_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_bottom_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_bottom_height_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_bottom_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bottom_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_bottom_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_bottom_height_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BD) ((arg1)->bottom_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_indicator_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_indicator_alpha_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_alpha_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_alpha_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->indicator_alpha = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_indicator_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_alpha_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BS) ((arg1)->indicator_alpha);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_indicator_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_indicator_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_color_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->indicator_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_indicator_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_indicator_color_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->indicator_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_num_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_num_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_num_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_num_verts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_num_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_num_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_verts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_verts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_verts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_verts_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_verts_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->verts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_verts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_verts_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_3BD *) ((arg1)->verts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_num_blverts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_num_blverts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_num_blverts_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SECTIONOBJECT_num_blverts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blverts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_num_blverts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_num_blverts_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blverts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_blverts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_blverts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_blverts_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_blverts_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->blverts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_blverts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_blverts_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_3BD *) ((arg1)->blverts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_section_settings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SECTIONOBJECT_section_settings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_section_settings_set" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SECTIONOBJECT_section_settings_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->section_settings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SECTIONOBJECT_section_settings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SECTIONOBJECT_section_settings_get" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  result = (BITCODE_H) ((arg1)->section_settings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SECTIONOBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SECTIONOBJECT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SECTIONOBJECT *)calloc(1, sizeof(struct _dwg_entity_SECTIONOBJECT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SECTIONOBJECT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SECTIONOBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SECTIONOBJECT *arg1 = (struct _dwg_entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SECTIONOBJECT" "', argument " "1"" of type '" "struct _dwg_entity_SECTIONOBJECT *""'"); 
  }
  arg1 = (struct _dwg_entity_SECTIONOBJECT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SECTIONOBJECT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SECTIONOBJECT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SECTIONOBJECT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_description_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_description_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_style_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_style_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_style_type_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_style_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->style_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_style_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_style_type_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->style_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_ext_lighting_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_ext_lighting_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_ext_lighting_model_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_ext_lighting_model_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->ext_lighting_model = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_ext_lighting_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_ext_lighting_model_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->ext_lighting_model);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_internal_only_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_internal_only_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_internal_only_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_internal_only_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->internal_only = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_internal_only_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_internal_only_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->internal_only);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_lighting_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face_lighting_model = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->face_lighting_model);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_lighting_model_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_lighting_model_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_model_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_lighting_model_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_lighting_quality_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face_lighting_quality = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->face_lighting_quality);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_lighting_quality_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_lighting_quality_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_color_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_color_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face_color_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_color_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->face_color_mode);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_color_mode_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_color_mode_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_color_mode_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_color_mode_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_color_mode_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_color_mode_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_opacity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_opacity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->face_opacity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_opacity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->face_opacity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_opacity_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_opacity_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_opacity_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_opacity_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_opacity_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_opacity_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_specular_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_specular_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->face_specular = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_specular_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->face_specular);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_specular_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_specular_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_specular_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_specular_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_specular_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_specular_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_modifier_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_modifier_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->face_modifier = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_modifier_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->face_modifier);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_modifier_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_modifier_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_modifier_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_modifier_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_modifier_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_modifier_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_mono_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_mono_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->face_mono_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_mono_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->face_mono_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_mono_color_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_face_mono_color_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_mono_color_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_face_mono_color_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_face_mono_color_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_mono_color_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_model = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_model);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_model_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_model_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_model_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_model_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_model_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_model_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_style);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_style_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_style_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_style_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_intersection_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->edge_intersection_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->edge_intersection_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_intersection_color_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_intersection_color_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_obscured_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->edge_obscured_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->edge_obscured_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_obscured_color_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_obscured_color_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_obscured_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_obscured_ltype);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_obscured_ltype_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_obscured_ltype_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_intersection_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_intersection_ltype);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_intersection_ltype_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_intersection_ltype_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_crease_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->edge_crease_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->edge_crease_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_crease_angle_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_crease_angle_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_modifier_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_modifier_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_modifier = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_modifier_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_modifier);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_modifier_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_modifier_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_modifier_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_modifier_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_modifier_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_modifier_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->edge_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->edge_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_color_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_color_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_color_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_color_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_color_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_color_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_opacity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_opacity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->edge_opacity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_opacity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->edge_opacity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_opacity_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_opacity_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_opacity_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_opacity_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_opacity_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_opacity_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_width);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_width_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_width_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_width_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_width_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_width_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_width_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_overhang_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_overhang_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_overhang = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_overhang_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_overhang);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_overhang_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_overhang_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_overhang_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_overhang_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_overhang_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_overhang_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_jitter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_jitter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_jitter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_jitter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_jitter);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_jitter_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_jitter_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_jitter_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_jitter_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_jitter_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_jitter_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_silhouette_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->edge_silhouette_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->edge_silhouette_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_silhouette_color_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_silhouette_color_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_silhouette_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_silhouette_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_silhouette_width);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_silhouette_width_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_silhouette_width_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_halo_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_halo_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_halo_gap);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_halo_gap_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_halo_gap_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_isolines_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_isolines_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_isolines_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_isolines_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_isolines_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_isolines_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->edge_do_hide_precision = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->edge_do_hide_precision);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_do_hide_precision_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_do_hide_precision_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_style_apply_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_style_apply = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_style_apply);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_style_apply_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_style_apply_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_style_apply_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_style_apply_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_settings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_settings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_settings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_settings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_settings);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_settings_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_settings_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_settings_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_settings_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_settings_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_settings_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_bl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_brightness_bl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_bl_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_bl_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->display_brightness_bl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_bl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_bl_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->display_brightness_bl);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->display_brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->display_brightness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_brightness_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_brightness_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_brightness_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_brightness_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_brightness_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_shadow_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_shadow_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_shadow_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_display_shadow_type_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_shadow_type_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_display_shadow_type_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_shadow_type_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd2007_45_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd2007_45_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd2007_45_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd2007_45_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd2007_45 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd2007_45_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd2007_45_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd2007_45);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_num_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_num_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_num_props_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_num_props_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_num_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_num_props_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1c_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop1c = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop1c);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1c_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1c_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop1c_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1c_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1c_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop1c_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop1d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop1d);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1d_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1d_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop1d_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1d_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1d_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop1d_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1e_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1e_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop1e = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1e_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop1e);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1e_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1e_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop1e_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1e_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1e_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop1e_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1f_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1f_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop1f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1f_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop1f);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1f_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop1f_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop1f_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop1f_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop1f_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop1f_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop20_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop20_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop20 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop20_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop20);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop20_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop20_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop20_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop20_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop20_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop20_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop21_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop21_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop21 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop21_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop21);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop21_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop21_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop21_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop21_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop21_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop21_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop22_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop22_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop22 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop22_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop22);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop22_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop22_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop22_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop22_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop22_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop22_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop23_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop23_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop23 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop23_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop23);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop23_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop23_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop23_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop23_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop23_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop23_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop24_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop24_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop24 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop24_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop24);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop24_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop24_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop24_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop24_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop24_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop24_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop25_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop25_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop25 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop25_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop25);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop25_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop25_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop25_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop25_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop25_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop25_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop26_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop26_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd_prop26 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop26_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd_prop26);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop26_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop26_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bd_prop26_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop26_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop26_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bd_prop26_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop27_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop27_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd_prop27 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop27_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd_prop27);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop27_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop27_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bd_prop27_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop27_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop27_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bd_prop27_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop28_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop28_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop28 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop28_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop28);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop28_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop28_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop28_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop28_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop28_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop28_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop29_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop29_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->c_prop29 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop29_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->c_prop29);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop29_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop29_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->c_prop29_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop29_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop29_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->c_prop29_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop2a = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop2a);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2a_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop2a_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2a_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop2a_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop2b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop2b);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2b_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop2b_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2b_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop2b_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop2c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop2c_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->c_prop2c = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop2c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->c_prop2c);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop2c_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop2c_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->c_prop2c_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop2c_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop2c_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->c_prop2c_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop2d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop2d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop2d = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop2d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop2d);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop2d_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop2d_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop2d_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop2d_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop2d_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop2d_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2e_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop2e = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop2e);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2e_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop2e_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2e_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop2e_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2f_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop2f = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop2f);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop2f_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop2f_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop2f_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop2f_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop30_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop30_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop30 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop30_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop30);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop30_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop30_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop30_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop30_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop30_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop30_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop31_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop31_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop31 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop31_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop31);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop31_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop31_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop31_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop31_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop31_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop31_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop32_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl_prop32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl_prop32);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop32_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bl_prop32_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bl_prop32_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bl_prop32_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bl_prop32_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bl_prop32_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop33_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop33_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->c_prop33 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop33_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->c_prop33);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop33_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_c_prop33_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->c_prop33_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_c_prop33_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_c_prop33_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->c_prop33_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop34_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop34_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd_prop34 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop34_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd_prop34);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop34_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop34_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bd_prop34_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop34_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop34_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bd_prop34_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_wiggle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_wiggle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_wiggle);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_edge_wiggle_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_wiggle_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_edge_wiggle_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_wiggle_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_strokes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_strokes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_strokes_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_VISUALSTYLE_strokes_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->strokes);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->strokes = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->strokes = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_strokes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_strokes_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->strokes);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_strokes_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_strokes_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_strokes_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_strokes_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->strokes_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_strokes_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_strokes_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->strokes_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop37_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop37_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b_prop37 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop37_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b_prop37);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop37_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_b_prop37_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->b_prop37_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_b_prop37_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_b_prop37_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->b_prop37_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop38_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop38_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd_prop38 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop38_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd_prop38);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop38_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop38_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bd_prop38_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop38_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop38_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bd_prop38_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop39_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop39_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd_prop39 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop39_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd_prop39);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop39_int_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_VISUALSTYLE_bd_prop39_int_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_int_set" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_int_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bd_prop39_int = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_VISUALSTYLE_bd_prop39_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_VISUALSTYLE_bd_prop39_int_get" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->bd_prop39_int);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_VISUALSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_VISUALSTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_VISUALSTYLE *)calloc(1, sizeof(struct _dwg_object_VISUALSTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VISUALSTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_VISUALSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_VISUALSTYLE *arg1 = (struct _dwg_object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_VISUALSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_VISUALSTYLE" "', argument " "1"" of type '" "struct _dwg_object_VISUALSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_VISUALSTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_VISUALSTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_VISUALSTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_VISUALSTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  struct _dwg_object_LIGHTLIST *arg2 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LIGHTLIST_light_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_parent_set" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LIGHTLIST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LIGHTLIST_light_parent_set" "', argument " "2"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg2 = (struct _dwg_object_LIGHTLIST *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_LIGHTLIST *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_parent_get" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  result = (struct _dwg_object_LIGHTLIST *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LIGHTLIST_light_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_name_set" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LIGHTLIST_light_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_name_get" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_LIGHTLIST_light_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_handle_set" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_LIGHTLIST_light_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_LIGHTLIST_light_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_LIGHTLIST_light_handle_get" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_LIGHTLIST_light(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_LIGHTLIST_light", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_LIGHTLIST_light *)calloc(1, sizeof(struct _dwg_LIGHTLIST_light));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LIGHTLIST_light, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_LIGHTLIST_light(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_LIGHTLIST_light *arg1 = (struct _dwg_LIGHTLIST_light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_LIGHTLIST_light, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_LIGHTLIST_light" "', argument " "1"" of type '" "struct _dwg_LIGHTLIST_light *""'"); 
  }
  arg1 = (struct _dwg_LIGHTLIST_light *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_LIGHTLIST_light_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_LIGHTLIST_light, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_LIGHTLIST_light_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LIGHTLIST_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LIGHTLIST_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LIGHTLIST_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LIGHTLIST_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_num_lights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LIGHTLIST_num_lights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_num_lights_set" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LIGHTLIST_num_lights_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_lights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_num_lights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_num_lights_get" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_lights);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_lights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  Dwg_LIGHTLIST_light *arg2 = (Dwg_LIGHTLIST_light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LIGHTLIST_lights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_lights_set" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_LIGHTLIST_light, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LIGHTLIST_lights_set" "', argument " "2"" of type '" "Dwg_LIGHTLIST_light *""'"); 
  }
  arg2 = (Dwg_LIGHTLIST_light *)(argp2);
  if (arg1) (arg1)->lights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LIGHTLIST_lights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_LIGHTLIST_light *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LIGHTLIST_lights_get" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  result = (Dwg_LIGHTLIST_light *) ((arg1)->lights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_LIGHTLIST_light, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LIGHTLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LIGHTLIST", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LIGHTLIST *)calloc(1, sizeof(struct _dwg_object_LIGHTLIST));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LIGHTLIST, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LIGHTLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LIGHTLIST *arg1 = (struct _dwg_object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LIGHTLIST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LIGHTLIST" "', argument " "1"" of type '" "struct _dwg_object_LIGHTLIST *""'"); 
  }
  arg1 = (struct _dwg_object_LIGHTLIST *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LIGHTLIST_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LIGHTLIST, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LIGHTLIST_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_color_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_parent_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_color_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_parent_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_color_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_flag_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_color_flag_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_flag_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_color_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_factor_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_color_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_factor_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  result = (BITCODE_BD) ((arg1)->factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_rgb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_color_rgb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_rgb_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_color_rgb_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->rgb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_color_rgb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_color_rgb_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  result = (BITCODE_BL) ((arg1)->rgb);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MATERIAL_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MATERIAL_color", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MATERIAL_color *)calloc(1, sizeof(struct _dwg_MATERIAL_color));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MATERIAL_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_color *arg1 = (struct _dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_color, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MATERIAL_color" "', argument " "1"" of type '" "struct _dwg_MATERIAL_color *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_color *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MATERIAL_color_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MATERIAL_color, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MATERIAL_color_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_parent_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_mapper_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_parent_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_blendfactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_blendfactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_blendfactor_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_blendfactor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->blendfactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_blendfactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_blendfactor_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_BD) ((arg1)->blendfactor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_mapper_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_filename_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_mapper_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_filename_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_TV) ((arg1)->filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_color1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  Dwg_MATERIAL_color *arg2 = (Dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_color1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_color1_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_mapper_color1_set" "', argument " "2"" of type '" "Dwg_MATERIAL_color *""'"); 
  }
  arg2 = (Dwg_MATERIAL_color *)(argp2);
  if (arg1) (arg1)->color1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_color1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_color1_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (Dwg_MATERIAL_color *)& ((arg1)->color1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_color2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  Dwg_MATERIAL_color *arg2 = (Dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_color2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_color2_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_mapper_color2_set" "', argument " "2"" of type '" "Dwg_MATERIAL_color *""'"); 
  }
  arg2 = (Dwg_MATERIAL_color *)(argp2);
  if (arg1) (arg1)->color2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_color2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_color2_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (Dwg_MATERIAL_color *)& ((arg1)->color2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_source_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_source_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_source_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_source_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->source = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_source_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_source_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_RC) ((arg1)->source);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_projection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_projection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_projection_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_projection_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->projection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_projection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_projection_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_RC) ((arg1)->projection);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_tiling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_tiling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_tiling_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_tiling_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->tiling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_tiling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_tiling_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_RC) ((arg1)->tiling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_autotransform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_autotransform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_autotransform_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_autotransform_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->autotransform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_autotransform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_autotransform_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_RC) ((arg1)->autotransform);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_texturemode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_mapper_texturemode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_texturemode_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MATERIAL_mapper_texturemode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->texturemode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_mapper_texturemode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_mapper_texturemode_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  result = (BITCODE_BS) ((arg1)->texturemode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MATERIAL_mapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MATERIAL_mapper", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MATERIAL_mapper *)calloc(1, sizeof(struct _dwg_MATERIAL_mapper));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MATERIAL_mapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_mapper *arg1 = (struct _dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_mapper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MATERIAL_mapper" "', argument " "1"" of type '" "struct _dwg_MATERIAL_mapper *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_mapper *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MATERIAL_mapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MATERIAL_mapper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MATERIAL_mapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  struct _dwg_object_MATERIAL *arg2 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_gentexture_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_parent_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MATERIAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_gentexture_parent_set" "', argument " "2"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg2 = (struct _dwg_object_MATERIAL *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_MATERIAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_parent_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  result = (struct _dwg_object_MATERIAL *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_genprocname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_gentexture_genprocname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_genprocname_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_gentexture_genprocname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->genprocname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->genprocname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->genprocname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_genprocname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_genprocname_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  result = (BITCODE_TV) ((arg1)->genprocname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  struct _dwg_object_MATERIAL *arg2 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MATERIAL_gentexture_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_material_set" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MATERIAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MATERIAL_gentexture_material_set" "', argument " "2"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg2 = (struct _dwg_object_MATERIAL *)(argp2);
  if (arg1) (arg1)->material = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MATERIAL_gentexture_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_MATERIAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MATERIAL_gentexture_material_get" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  result = (struct _dwg_object_MATERIAL *) ((arg1)->material);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MATERIAL_gentexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MATERIAL_gentexture", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MATERIAL_gentexture *)calloc(1, sizeof(struct _dwg_MATERIAL_gentexture));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_gentexture, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MATERIAL_gentexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MATERIAL_gentexture *arg1 = (struct _dwg_MATERIAL_gentexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MATERIAL_gentexture, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MATERIAL_gentexture" "', argument " "1"" of type '" "struct _dwg_MATERIAL_gentexture *""'"); 
  }
  arg1 = (struct _dwg_MATERIAL_gentexture *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MATERIAL_gentexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MATERIAL_gentexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MATERIAL_gentexture_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_name_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_name_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_description_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_description_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_ambient_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_color *arg2 = (Dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_ambient_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_ambient_color_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_ambient_color_set" "', argument " "2"" of type '" "Dwg_MATERIAL_color *""'"); 
  }
  arg2 = (Dwg_MATERIAL_color *)(argp2);
  if (arg1) (arg1)->ambient_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_ambient_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_ambient_color_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_color *)& ((arg1)->ambient_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_diffuse_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_color *arg2 = (Dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_diffuse_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_diffuse_color_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_diffuse_color_set" "', argument " "2"" of type '" "Dwg_MATERIAL_color *""'"); 
  }
  arg2 = (Dwg_MATERIAL_color *)(argp2);
  if (arg1) (arg1)->diffuse_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_diffuse_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_diffuse_color_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_color *)& ((arg1)->diffuse_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_diffusemap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_diffusemap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_diffusemap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_diffusemap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->diffusemap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_diffusemap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_diffusemap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->diffusemap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specular_gloss_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_specular_gloss_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specular_gloss_factor_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_specular_gloss_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->specular_gloss_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specular_gloss_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specular_gloss_factor_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->specular_gloss_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specular_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_color *arg2 = (Dwg_MATERIAL_color *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_specular_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specular_color_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_specular_color_set" "', argument " "2"" of type '" "Dwg_MATERIAL_color *""'"); 
  }
  arg2 = (Dwg_MATERIAL_color *)(argp2);
  if (arg1) (arg1)->specular_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specular_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_color *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specular_color_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_color *)& ((arg1)->specular_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specularmap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_specularmap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specularmap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_specularmap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->specularmap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_specularmap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_specularmap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->specularmap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectionmap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_reflectionmap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectionmap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_reflectionmap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->reflectionmap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectionmap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectionmap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->reflectionmap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_opacity_percent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_opacity_percent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_opacity_percent_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_opacity_percent_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->opacity_percent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_opacity_percent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_opacity_percent_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->opacity_percent);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_opacitymap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_opacitymap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_opacitymap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_opacitymap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->opacitymap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_opacitymap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_opacitymap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->opacitymap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_bumpmap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_bumpmap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_bumpmap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_bumpmap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->bumpmap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_bumpmap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_bumpmap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->bumpmap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_refraction_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_refraction_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_refraction_index_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_refraction_index_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->refraction_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_refraction_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_refraction_index_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->refraction_index);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_refractionmap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_mapper *arg2 = (Dwg_MATERIAL_mapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_refractionmap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_refractionmap_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_refractionmap_set" "', argument " "2"" of type '" "Dwg_MATERIAL_mapper *""'"); 
  }
  arg2 = (Dwg_MATERIAL_mapper *)(argp2);
  if (arg1) (arg1)->refractionmap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_refractionmap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_mapper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_refractionmap_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_mapper *)& ((arg1)->refractionmap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_mapper, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_color_bleed_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_color_bleed_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_color_bleed_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_color_bleed_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->color_bleed_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_color_bleed_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_color_bleed_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->color_bleed_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_indirect_bump_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_indirect_bump_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_indirect_bump_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_indirect_bump_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->indirect_bump_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_indirect_bump_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_indirect_bump_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->indirect_bump_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectance_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_reflectance_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectance_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_reflectance_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->reflectance_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectance_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectance_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->reflectance_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_transmittance_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_transmittance_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_transmittance_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_transmittance_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->transmittance_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_transmittance_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_transmittance_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->transmittance_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_two_sided_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_two_sided_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_two_sided_material_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_two_sided_material_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->two_sided_material = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_two_sided_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_two_sided_material_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_B) ((arg1)->two_sided_material);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_luminance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_luminance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_luminance_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_luminance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->luminance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_luminance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_luminance_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->luminance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_luminance_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_luminance_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_luminance_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_luminance_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->luminance_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_luminance_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_luminance_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BS) ((arg1)->luminance_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_translucence_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_translucence_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_translucence_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_translucence_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->translucence = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_translucence_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_translucence_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->translucence);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_self_illumination_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_self_illumination_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_self_illumination_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_self_illumination_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->self_illumination = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_self_illumination_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_self_illumination_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->self_illumination);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectivity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_reflectivity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectivity_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_reflectivity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->reflectivity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_reflectivity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_reflectivity_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->reflectivity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_illumination_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_illumination_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_illumination_model_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_illumination_model_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->illumination_model = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_illumination_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_illumination_model_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->illumination_model);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_channel_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_channel_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_channel_flags_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_channel_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->channel_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_channel_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_channel_flags_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->channel_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_mode_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->mode);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocname_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_genprocname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->genprocname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->genprocname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->genprocname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocname_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_TV) ((arg1)->genprocname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genproctype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genproctype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genproctype_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_genproctype_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->genproctype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genproctype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genproctype_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BS) ((arg1)->genproctype);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalbool_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocvalbool_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalbool_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_genprocvalbool_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->genprocvalbool = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalbool_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalbool_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_B) ((arg1)->genprocvalbool);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocvalint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalint_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_genprocvalint_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->genprocvalint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalint_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BS) ((arg1)->genprocvalint);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalreal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocvalreal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalreal_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_genprocvalreal_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->genprocvalreal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalreal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalreal_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BD) ((arg1)->genprocvalreal);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvaltext_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocvaltext_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvaltext_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_genprocvaltext_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->genprocvaltext);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->genprocvaltext = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->genprocvaltext = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvaltext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvaltext_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_TV) ((arg1)->genprocvaltext);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalcolor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genprocvalcolor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalcolor_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_genprocvalcolor_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->genprocvalcolor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genprocvalcolor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genprocvalcolor_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->genprocvalcolor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genproctableend_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_genproctableend_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genproctableend_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_genproctableend_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->genproctableend = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_genproctableend_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_genproctableend_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_B) ((arg1)->genproctableend);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_num_gentextures_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_num_gentextures_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_num_gentextures_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MATERIAL_num_gentextures_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_gentextures = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_num_gentextures_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_num_gentextures_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_gentextures);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_gentextures_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  Dwg_MATERIAL_gentexture *arg2 = (Dwg_MATERIAL_gentexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MATERIAL_gentextures_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_gentextures_set" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MATERIAL_gentexture, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MATERIAL_gentextures_set" "', argument " "2"" of type '" "Dwg_MATERIAL_gentexture *""'"); 
  }
  arg2 = (Dwg_MATERIAL_gentexture *)(argp2);
  if (arg1) (arg1)->gentextures = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MATERIAL_gentextures_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MATERIAL_gentexture *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MATERIAL_gentextures_get" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  result = (Dwg_MATERIAL_gentexture *) ((arg1)->gentextures);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MATERIAL_gentexture, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MATERIAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MATERIAL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MATERIAL *)calloc(1, sizeof(struct _dwg_object_MATERIAL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MATERIAL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MATERIAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MATERIAL *arg1 = (struct _dwg_object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MATERIAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MATERIAL" "', argument " "1"" of type '" "struct _dwg_object_MATERIAL *""'"); 
  }
  arg1 = (struct _dwg_object_MATERIAL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MATERIAL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MATERIAL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MATERIAL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_OBJECT_PTR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_OBJECT_PTR *arg1 = (struct _dwg_object_OBJECT_PTR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_OBJECT_PTR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_OBJECT_PTR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_OBJECT_PTR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_OBJECT_PTR *""'"); 
  }
  arg1 = (struct _dwg_object_OBJECT_PTR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_OBJECT_PTR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_OBJECT_PTR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_OBJECT_PTR *arg1 = (struct _dwg_object_OBJECT_PTR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_OBJECT_PTR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_OBJECT_PTR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_OBJECT_PTR *""'"); 
  }
  arg1 = (struct _dwg_object_OBJECT_PTR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_OBJECT_PTR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_OBJECT_PTR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_OBJECT_PTR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_OBJECT_PTR *)calloc(1, sizeof(struct _dwg_object_OBJECT_PTR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_OBJECT_PTR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_OBJECT_PTR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_OBJECT_PTR *arg1 = (struct _dwg_object_OBJECT_PTR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_OBJECT_PTR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_OBJECT_PTR" "', argument " "1"" of type '" "struct _dwg_object_OBJECT_PTR *""'"); 
  }
  arg1 = (struct _dwg_object_OBJECT_PTR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_OBJECT_PTR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_OBJECT_PTR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_OBJECT_PTR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_name_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_name_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_status_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_status_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_status_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_light_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_light_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_light_color_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_light_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->light_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_light_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_light_color_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->light_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_plot_glyph_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_plot_glyph_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_plot_glyph_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_plot_glyph_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->plot_glyph = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_plot_glyph_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_plot_glyph_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->plot_glyph);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_intensity_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_intensity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_intensity_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->intensity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_position_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_position_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_position_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_target_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_target_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->target = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_target_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_attenuation_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_attenuation_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->attenuation_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BL) ((arg1)->attenuation_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_use_attenuation_limits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_use_attenuation_limits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_use_attenuation_limits_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_use_attenuation_limits_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_attenuation_limits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_use_attenuation_limits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_use_attenuation_limits_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->use_attenuation_limits);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_start_limit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_attenuation_start_limit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_start_limit_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_attenuation_start_limit_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->attenuation_start_limit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_start_limit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_start_limit_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->attenuation_start_limit);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_end_limit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_attenuation_end_limit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_end_limit_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_attenuation_end_limit_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->attenuation_end_limit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_attenuation_end_limit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_attenuation_end_limit_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->attenuation_end_limit);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_hotspot_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_hotspot_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_hotspot_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_hotspot_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->hotspot_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_hotspot_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_hotspot_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->hotspot_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_falloff_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_falloff_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_falloff_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_falloff_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->falloff_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_falloff_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_falloff_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->falloff_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_cast_shadows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_cast_shadows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_cast_shadows_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_cast_shadows_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->cast_shadows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_cast_shadows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_cast_shadows_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->cast_shadows);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_shadow_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_shadow_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shadow_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BL) ((arg1)->shadow_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_map_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_shadow_map_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_map_size_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_shadow_map_size_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadow_map_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_map_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_map_size_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadow_map_size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_map_softness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_shadow_map_softness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_map_softness_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_shadow_map_softness_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->shadow_map_softness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_shadow_map_softness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_shadow_map_softness_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_RC) ((arg1)->shadow_map_softness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_is_photometric_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_is_photometric_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_is_photometric_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_is_photometric_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_photometric = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_is_photometric_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_is_photometric_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->is_photometric);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_photometric_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_has_photometric_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_photometric_data_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_has_photometric_data_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_photometric_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_photometric_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_photometric_data_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->has_photometric_data);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_webfile_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_has_webfile_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_webfile_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_has_webfile_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_webfile = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_webfile_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_webfile_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_B) ((arg1)->has_webfile);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_webfile_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_webfile_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_webfile_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_webfile_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->webfile);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->webfile = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->webfile = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_webfile_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_webfile_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_TV) ((arg1)->webfile);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_physical_intensity_method_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_physical_intensity_method_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_physical_intensity_method_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_physical_intensity_method_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->physical_intensity_method = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_physical_intensity_method_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_physical_intensity_method_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->physical_intensity_method);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_physical_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_physical_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_physical_intensity_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_physical_intensity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->physical_intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_physical_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_physical_intensity_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->physical_intensity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_illuminance_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_illuminance_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_illuminance_dist_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_illuminance_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->illuminance_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_illuminance_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_illuminance_dist_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->illuminance_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_lamp_color_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_lamp_color_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lamp_color_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->lamp_color_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_temp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_lamp_color_temp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_temp_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_lamp_color_temp_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->lamp_color_temp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_temp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_temp_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->lamp_color_temp);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_preset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_lamp_color_preset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_preset_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_lamp_color_preset_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->lamp_color_preset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_preset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_preset_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->lamp_color_preset);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_rgb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_lamp_color_rgb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_rgb_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_lamp_color_rgb_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->lamp_color_rgb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_lamp_color_rgb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_lamp_color_rgb_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BL) ((arg1)->lamp_color_rgb);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LIGHT_web_rotation_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->web_rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->web_rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_shape_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_extlight_shape_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_shape_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_extlight_shape_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->extlight_shape = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_shape_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_shape_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->extlight_shape);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_extlight_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_length_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_extlight_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extlight_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_length_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->extlight_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_extlight_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_width_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_extlight_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extlight_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_width_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->extlight_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_extlight_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_extlight_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extlight_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_extlight_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_extlight_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->extlight_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_webfile_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_webfile_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_webfile_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_webfile_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->webfile_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_webfile_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_webfile_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->webfile_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_symetry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_symetry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_symetry_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_symetry_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->web_symetry = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_symetry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_symetry_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->web_symetry);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_target_grip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_has_target_grip_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_target_grip_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_has_target_grip_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->has_target_grip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_has_target_grip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_has_target_grip_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->has_target_grip);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_flux_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_flux_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_flux_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_flux_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_flux = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_flux_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_flux_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_flux);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_angle1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle1_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_angle1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_angle1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle1_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_angle1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_angle2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle2_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_angle2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_angle2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle2_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_angle2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_angle3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle3_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_angle3_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_angle3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle3_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_angle3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_angle4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle4_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_angle4_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_angle4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle4_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_angle4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_web_angle5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle5_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_web_angle5_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->web_angle5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_web_angle5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_web_angle5_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BD) ((arg1)->web_angle5);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_glyph_display_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LIGHT_glyph_display_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_glyph_display_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LIGHT_glyph_display_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->glyph_display_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LIGHT_glyph_display_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LIGHT_glyph_display_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  result = (BITCODE_BS) ((arg1)->glyph_display_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LIGHT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LIGHT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LIGHT *)calloc(1, sizeof(struct _dwg_entity_LIGHT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LIGHT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LIGHT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LIGHT *arg1 = (struct _dwg_entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LIGHT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LIGHT" "', argument " "1"" of type '" "struct _dwg_entity_LIGHT *""'"); 
  }
  arg1 = (struct _dwg_entity_LIGHT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LIGHT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LIGHT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LIGHT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_CAMERA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *arg1 = (struct _dwg_entity_CAMERA *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CAMERA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CAMERA_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_CAMERA *""'"); 
  }
  arg1 = (struct _dwg_entity_CAMERA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_CAMERA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CAMERA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *arg1 = (struct _dwg_entity_CAMERA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CAMERA_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_CAMERA *""'"); 
  }
  arg1 = (struct _dwg_entity_CAMERA *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CAMERA_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *arg1 = (struct _dwg_entity_CAMERA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_CAMERA_view_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CAMERA_view_set" "', argument " "1"" of type '" "struct _dwg_entity_CAMERA *""'"); 
  }
  arg1 = (struct _dwg_entity_CAMERA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_CAMERA_view_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_CAMERA_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *arg1 = (struct _dwg_entity_CAMERA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_CAMERA_view_get" "', argument " "1"" of type '" "struct _dwg_entity_CAMERA *""'"); 
  }
  arg1 = (struct _dwg_entity_CAMERA *)(argp1);
  result = (BITCODE_H) ((arg1)->view);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_CAMERA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_CAMERA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_CAMERA *)calloc(1, sizeof(struct _dwg_entity_CAMERA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CAMERA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_CAMERA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_CAMERA *arg1 = (struct _dwg_entity_CAMERA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_CAMERA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_CAMERA" "', argument " "1"" of type '" "struct _dwg_entity_CAMERA *""'"); 
  }
  arg1 = (struct _dwg_entity_CAMERA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_CAMERA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_CAMERA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_CAMERA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_position_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_position_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_position_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->landing_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_landing_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_BD) ((arg1)->landing_gap);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_notes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_notes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_notes_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_notes_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->notes);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->notes = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->notes = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_notes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_notes_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_TV) ((arg1)->notes);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->text_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_text_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_RC) ((arg1)->text_alignment);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->mtext_visible = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_B) ((arg1)->mtext_visible);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->enable_frame_text = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_B) ((arg1)->enable_frame_text);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  Dwg_AcDbMTextObjectEmbedded *arg2 = (Dwg_AcDbMTextObjectEmbedded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_mtext_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_set" "', argument " "2"" of type '" "Dwg_AcDbMTextObjectEmbedded *""'"); 
  }
  arg2 = (Dwg_AcDbMTextObjectEmbedded *)(argp2);
  if (arg1) (arg1)->mtext = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDbMTextObjectEmbedded *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_mtext_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (Dwg_AcDbMTextObjectEmbedded *)& ((arg1)->mtext);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDbMTextObjectEmbedded, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_really_locked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_really_locked);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_data_size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->annotative_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_RC *) ((arg1)->annotative_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->annotative_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_BS) ((arg1)->annotative_flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->annotative_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_get" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  result = (BITCODE_H) ((arg1)->annotative_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_GEOPOSITIONMARKER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_GEOPOSITIONMARKER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_GEOPOSITIONMARKER *)calloc(1, sizeof(struct _dwg_entity_GEOPOSITIONMARKER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_GEOPOSITIONMARKER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_GEOPOSITIONMARKER *arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_GEOPOSITIONMARKER" "', argument " "1"" of type '" "struct _dwg_entity_GEOPOSITIONMARKER *""'"); 
  }
  arg1 = (struct _dwg_entity_GEOPOSITIONMARKER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_GEOPOSITIONMARKER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_GEOPOSITIONMARKER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEOMAPIMAGE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_pt0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_pt0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_pt0_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEOMAPIMAGE_pt0_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_pt0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_pt0_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_image_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_size_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEOMAPIMAGE_image_size_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->image_size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_size_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->image_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_display_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_display_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_display_props_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_display_props_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->display_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_display_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_display_props_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->display_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_clipping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_clipping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_clipping_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_clipping_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->clipping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_clipping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_clipping_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_B) ((arg1)->clipping);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_brightness_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_brightness_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_brightness_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->brightness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_contrast_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_contrast_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_contrast_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->contrast);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_fade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_fade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_fade_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_fade_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_fade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_fade_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_RC) ((arg1)->fade);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_image_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_width_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_image_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->image_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_width_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->image_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_image_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_height_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_image_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->image_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_height_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->image_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_name_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GEOMAPIMAGE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_name_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_file_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_image_file_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_file_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_image_file_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->image_file = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_file_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->image_file);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_image_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_visibility_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_image_visibility_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->image_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_image_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_image_visibility_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->image_visibility);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_transparency_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_transparency_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_transparency_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->transparency);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_height_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_height_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_width_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_width_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_show_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_show_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_show_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_show_rotation_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_show_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_show_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_B) ((arg1)->show_rotation);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_brightness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_brightness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_brightness);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_contrast = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_contrast_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_contrast);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_fade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_fade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_fade_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_fade_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_fade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_fade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_fade_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_fade);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_position_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_position_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_position = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_position_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_position);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_width_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_width_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_width_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_width);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GEOMAPIMAGE_geoimage_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_height_set" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_height_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->geoimage_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GEOMAPIMAGE_geoimage_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GEOMAPIMAGE_geoimage_height_get" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  result = (BITCODE_BS) ((arg1)->geoimage_height);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_GEOMAPIMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_GEOMAPIMAGE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_GEOMAPIMAGE *)calloc(1, sizeof(struct _dwg_object_GEOMAPIMAGE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GEOMAPIMAGE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_GEOMAPIMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GEOMAPIMAGE *arg1 = (struct _dwg_object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_GEOMAPIMAGE" "', argument " "1"" of type '" "struct _dwg_object_GEOMAPIMAGE *""'"); 
  }
  arg1 = (struct _dwg_object_GEOMAPIMAGE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_GEOMAPIMAGE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_GEOMAPIMAGE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_GEOMAPIMAGE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_scenario_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_scenario_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_scenario_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_scenario_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->scenario = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_scenario_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_scenario_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BS) ((arg1)->scenario);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_degree_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_degree_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_degree_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_degree_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->degree = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_degree_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_degree_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BS) ((arg1)->degree);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_splineflags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_splineflags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_splineflags_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_splineflags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->splineflags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_splineflags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_splineflags_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->splineflags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knotparam_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_knotparam_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knotparam_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_knotparam_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->knotparam = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knotparam_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knotparam_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->knotparam);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_fit_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_fit_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_fit_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_fit_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fit_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_fit_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_fit_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->fit_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_beg_tan_vec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_beg_tan_vec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_beg_tan_vec_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_beg_tan_vec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->beg_tan_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_beg_tan_vec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_beg_tan_vec_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->beg_tan_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_end_tan_vec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_end_tan_vec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_end_tan_vec_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_end_tan_vec_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->end_tan_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_end_tan_vec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_end_tan_vec_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->end_tan_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_rational_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_rational_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_rational_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_rational_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->rational = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_rational_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_rational_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_B) ((arg1)->rational);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_closed_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_closed_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_closed_b_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_closed_b_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->closed_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_closed_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_closed_b_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_B) ((arg1)->closed_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_periodic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_periodic_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_periodic_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_periodic_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->periodic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_periodic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_periodic_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_B) ((arg1)->periodic);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_weighted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_weighted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_weighted_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_weighted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->weighted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_weighted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_weighted_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_B) ((arg1)->weighted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knot_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_knot_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knot_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_knot_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->knot_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knot_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knot_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->knot_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_ctrl_tol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_ctrl_tol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_ctrl_tol_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_ctrl_tol_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ctrl_tol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_ctrl_tol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_ctrl_tol_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->ctrl_tol);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_fit_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_num_fit_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_fit_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_num_fit_pts_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_fit_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_fit_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_fit_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_fit_pts);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_fit_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_fit_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_fit_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_fit_pts_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->fit_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_fit_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_fit_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->fit_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_num_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_knots_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_num_knots_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_knots_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_knots);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knots_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_knots_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knots_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_knots_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->knots = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_knots_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_knots_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD *) ((arg1)->knots);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_ctrl_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_num_ctrl_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_ctrl_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_num_ctrl_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_ctrl_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_num_ctrl_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_num_ctrl_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_ctrl_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_ctrl_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  Dwg_SPLINE_control_point *arg2 = (Dwg_SPLINE_control_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_ctrl_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_ctrl_pts_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SPLINE_control_point, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_ctrl_pts_set" "', argument " "2"" of type '" "Dwg_SPLINE_control_point *""'"); 
  }
  arg2 = (Dwg_SPLINE_control_point *)(argp2);
  if (arg1) (arg1)->ctrl_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_ctrl_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SPLINE_control_point *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_ctrl_pts_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (Dwg_SPLINE_control_point *) ((arg1)->ctrl_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SPLINE_control_point, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_major_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_major_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_major_version_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_major_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_major_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_major_version_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->major_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_maint_version_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_maint_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_maint_version_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BL) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_axis_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_axis_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_axis_base_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_axis_base_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_axis_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_axis_base_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_start_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_start_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_start_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_start_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->start_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_start_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_start_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->start_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_axis_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_axis_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_axis_vector_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_HELIX_axis_vector_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_axis_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_axis_vector_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_turns_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_turns_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_turns_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_turns_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->turns = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_turns_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_turns_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->turns);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_turn_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_turn_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_turn_height_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_turn_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->turn_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_turn_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_turn_height_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_BD) ((arg1)->turn_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_handedness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_handedness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_handedness_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_handedness_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->handedness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_handedness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_handedness_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_B) ((arg1)->handedness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_constraint_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_HELIX_constraint_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_constraint_type_set" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_HELIX_constraint_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->constraint_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_HELIX_constraint_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_HELIX_constraint_type_get" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  result = (BITCODE_RC) ((arg1)->constraint_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_HELIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_HELIX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_HELIX *)calloc(1, sizeof(struct _dwg_entity_HELIX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HELIX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_HELIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_HELIX *arg1 = (struct _dwg_entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_HELIX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_HELIX" "', argument " "1"" of type '" "struct _dwg_entity_HELIX *""'"); 
  }
  arg1 = (struct _dwg_entity_HELIX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_HELIX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_HELIX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_HELIX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->modeler_format_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->modeler_format_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bindata_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->bindata_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_bindata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->bindata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bindata_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_TF) ((arg1)->bindata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_start_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_start_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_end_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_end_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_align_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_align_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->align_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_align_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->align_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->sweep_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->sweep_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->path_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->path_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_is_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_is_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_is_solid_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_is_solid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_solid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_is_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_is_solid_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_solid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->sweep_alignment_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->sweep_alignment_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_path_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->path_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->path_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_align_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_align_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_start_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_start_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->align_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_align_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_align_start_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->align_start);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bank_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_bank_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bank_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bank_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_bank_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_bank_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->bank);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->base_point_set = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_base_point_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->base_point_set);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->sweep_entity_transform_computed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->sweep_entity_transform_computed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->path_entity_transform_computed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->path_entity_transform_computed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->reference_vector_for_controlling_twist = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->reference_vector_for_controlling_twist);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sweep_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->sweep_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_path_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->path_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_path_entity_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->path_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->sweep_vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->sweep_vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->sweep_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->sweep_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_EXTRUDEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_EXTRUDEDSURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_EXTRUDEDSURFACE *)calloc(1, sizeof(struct _dwg_entity_EXTRUDEDSURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_EXTRUDEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_EXTRUDEDSURFACE *arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_EXTRUDEDSURFACE" "', argument " "1"" of type '" "struct _dwg_entity_EXTRUDEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_EXTRUDEDSURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_EXTRUDEDSURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_EXTRUDEDSURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_modeler_format_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_modeler_format_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_modeler_format_version_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_modeler_format_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->modeler_format_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_modeler_format_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_modeler_format_version_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->modeler_format_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sweep_entity_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sweep_entity_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweepdata_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_size_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sweepdata_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_size_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sweepdata_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweepdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->sweepdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweepdata_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_TF) ((arg1)->sweepdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_path_entity_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_id_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->path_entity_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_id_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->path_entity_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_pathdata_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_pathdata_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_size_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pathdata_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_pathdata_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_size_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->pathdata_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_pathdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_pathdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->pathdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_pathdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_pathdata_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_TF) ((arg1)->pathdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_start_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_draft_start_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_start_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_start_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_start_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_start_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_start_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_start_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_end_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_draft_end_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_end_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_end_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_end_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_draft_end_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_draft_end_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_end_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_align_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_align_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_align_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_align_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->align_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_align_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_align_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->align_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->sweep_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->sweep_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->path_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->path_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_is_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_is_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_is_solid_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_is_solid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_solid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_is_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_is_solid_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_solid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->sweep_alignment_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->sweep_alignment_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_path_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_path_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->path_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->path_flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_align_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_align_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_align_start_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_align_start_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->align_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_align_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_align_start_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->align_start);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_bank_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_bank_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_bank_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_bank_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_bank_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_bank_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->bank);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_base_point_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_base_point_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_base_point_set_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_base_point_set_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->base_point_set = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_base_point_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_base_point_set_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->base_point_set);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->sweep_entity_transform_computed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->sweep_entity_transform_computed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->path_entity_transform_computed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->path_entity_transform_computed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->reference_vector_for_controlling_twist = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->reference_vector_for_controlling_twist);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_sweep_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sweep_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_sweep_entity_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->sweep_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_SWEPTSURFACE_path_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_set" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->path_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_SWEPTSURFACE_path_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_SWEPTSURFACE_path_entity_get" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->path_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_SWEPTSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_SWEPTSURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_SWEPTSURFACE *)calloc(1, sizeof(struct _dwg_entity_SWEPTSURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SWEPTSURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_SWEPTSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_SWEPTSURFACE *arg1 = (struct _dwg_entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_SWEPTSURFACE" "', argument " "1"" of type '" "struct _dwg_entity_SWEPTSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_SWEPTSURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_SWEPTSURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_SWEPTSURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_SWEPTSURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->modeler_format_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_modeler_format_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->modeler_format_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->loft_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->loft_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->plane_normal_lofting_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->plane_normal_lofting_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_draft_magnitude = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_draft_magnitude);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_draft_magnitude = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_draft_magnitude);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->arc_length_parameterization = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->arc_length_parameterization);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_no_twist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_no_twist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_no_twist_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_no_twist_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->no_twist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_no_twist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_no_twist_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->no_twist);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_align_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_align_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_align_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_align_direction_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->align_direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_align_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_align_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->align_direction);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->simple_surfaces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_simple_surfaces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->simple_surfaces);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->closed_surfaces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_closed_surfaces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->closed_surfaces);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_solid_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_solid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->solid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_solid_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->solid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_ruled_surface_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_ruled_surface_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_ruled_surface_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_ruled_surface_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ruled_surface = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_ruled_surface_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_ruled_surface_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->ruled_surface);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_virtual_guide_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_virtual_guide_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_virtual_guide_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_virtual_guide_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->virtual_guide = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_virtual_guide_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_virtual_guide_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->virtual_guide);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_cross_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_cross_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_cross_sections);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_guide_curves = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_num_guide_curves_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_guide_curves);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_cross_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_cross_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_cross_sections_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_cross_sections_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->cross_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_cross_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_cross_sections_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_H *) ((arg1)->cross_sections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_guide_curves_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_guide_curves_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_guide_curves_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_guide_curves_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->guide_curves = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_guide_curves_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_guide_curves_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_H *) ((arg1)->guide_curves);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_path_curve_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOFTEDSURFACE_path_curve_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_path_curve_set" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOFTEDSURFACE_path_curve_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->path_curve = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOFTEDSURFACE_path_curve_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOFTEDSURFACE_path_curve_get" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->path_curve);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LOFTEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LOFTEDSURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LOFTEDSURFACE *)calloc(1, sizeof(struct _dwg_entity_LOFTEDSURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LOFTEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOFTEDSURFACE *arg1 = (struct _dwg_entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LOFTEDSURFACE" "', argument " "1"" of type '" "struct _dwg_entity_LOFTEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_LOFTEDSURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LOFTEDSURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LOFTEDSURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_short170_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_short170_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_short170_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_short170_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->short170 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_short170_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_short170_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->short170);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_cv_hull_display_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_cv_hull_display_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_cv_hull_display_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NURBSURFACE_cv_hull_display_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->cv_hull_display = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_cv_hull_display_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_cv_hull_display_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->cv_hull_display);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_uvec1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_uvec1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_uvec1_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_uvec1_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->uvec1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_uvec1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_uvec1_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->uvec1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_vvec1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_vvec1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_vvec1_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_vvec1_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vvec1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_vvec1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_vvec1_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vvec1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_uvec2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_uvec2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_uvec2_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_uvec2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->uvec2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_uvec2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_uvec2_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->uvec2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_vvec2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NURBSURFACE_vvec2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_vvec2_set" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NURBSURFACE_vvec2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->vvec2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NURBSURFACE_vvec2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NURBSURFACE_vvec2_get" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->vvec2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_NURBSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_NURBSURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_NURBSURFACE *)calloc(1, sizeof(struct _dwg_entity_NURBSURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_NURBSURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_NURBSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NURBSURFACE *arg1 = (struct _dwg_entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NURBSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_NURBSURFACE" "', argument " "1"" of type '" "struct _dwg_entity_NURBSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_NURBSURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_NURBSURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_NURBSURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_NURBSURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_PLANESURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_modeler_format_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_modeler_format_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_modeler_format_version_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_modeler_format_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->modeler_format_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_modeler_format_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_modeler_format_version_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->modeler_format_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_PLANESURFACE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_PLANESURFACE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_PLANESURFACE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_PLANESURFACE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_PLANESURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_PLANESURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_PLANESURFACE *)calloc(1, sizeof(struct _dwg_entity_PLANESURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PLANESURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_PLANESURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_PLANESURFACE *arg1 = (struct _dwg_entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_PLANESURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_PLANESURFACE" "', argument " "1"" of type '" "struct _dwg_entity_PLANESURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_PLANESURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_PLANESURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_PLANESURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_PLANESURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_unknown_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_unknown_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_version_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_version_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_block_size_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_block_size_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_sab_size_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_sab_size_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_present_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_present_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_point_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wires_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_wires_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_num_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_materials_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_materials_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_major_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_major_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_end_marker_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_end_marker_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_history_id_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_history_id_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->modeler_format_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->modeler_format_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_u_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_u_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_u_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_u_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->u_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_u_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_u_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->u_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_v_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_v_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_v_isolines_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_v_isolines_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->v_isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_v_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_v_isolines_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BS) ((arg1)->v_isolines);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_id_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_id_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BL) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_axis_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_axis_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_point_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_axis_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_point_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_axis_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_axis_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_vector_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_vector_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_axis_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_axis_vector_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->revolve_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revolve_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->revolve_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_start_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_start_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->revolved_entity_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->revolved_entity_transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_start_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_start_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_end_distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_end_distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_solid_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_solid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->solid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_solid_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->solid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->close_to_axis = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REVOLVEDSURFACE_close_to_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_get" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  result = (BITCODE_B) ((arg1)->close_to_axis);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_REVOLVEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_REVOLVEDSURFACE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_REVOLVEDSURFACE *)calloc(1, sizeof(struct _dwg_entity_REVOLVEDSURFACE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_REVOLVEDSURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REVOLVEDSURFACE *arg1 = (struct _dwg_entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_REVOLVEDSURFACE" "', argument " "1"" of type '" "struct _dwg_entity_REVOLVEDSURFACE *""'"); 
  }
  arg1 = (struct _dwg_entity_REVOLVEDSURFACE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_REVOLVEDSURFACE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_REVOLVEDSURFACE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  struct _dwg_entity_MESH *arg2 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MESH_edge_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_parent_set" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MESH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_MESH_edge_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg2 = (struct _dwg_entity_MESH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_parent_get" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  result = (struct _dwg_entity_MESH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_idxfrom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MESH_edge_idxfrom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_idxfrom_set" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MESH_edge_idxfrom_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->idxfrom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_idxfrom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_idxfrom_get" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  result = (BITCODE_BL) ((arg1)->idxfrom);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_idxto_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_MESH_edge_idxto_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_idxto_set" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_MESH_edge_idxto_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->idxto = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_MESH_edge_idxto_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_MESH_edge_idxto_get" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  result = (BITCODE_BL) ((arg1)->idxto);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_MESH_edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_MESH_edge", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_MESH_edge *)calloc(1, sizeof(struct _dwg_MESH_edge));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MESH_edge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_MESH_edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_MESH_edge *arg1 = (struct _dwg_MESH_edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_MESH_edge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_MESH_edge" "', argument " "1"" of type '" "struct _dwg_MESH_edge *""'"); 
  }
  arg1 = (struct _dwg_MESH_edge *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_MESH_edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_MESH_edge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_MESH_edge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_dlevel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_dlevel_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_dlevel_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_dlevel_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->dlevel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_dlevel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_dlevel_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BS) ((arg1)->dlevel);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_is_watertight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_is_watertight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_is_watertight_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_is_watertight_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_watertight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_is_watertight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_is_watertight_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_B) ((arg1)->is_watertight);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_subdiv_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_num_subdiv_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_subdiv_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_num_subdiv_vertex_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_subdiv_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_subdiv_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_subdiv_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_subdiv_vertex);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_subdiv_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_subdiv_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_subdiv_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_subdiv_vertex_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->subdiv_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_subdiv_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_subdiv_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->subdiv_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_num_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_num_vertex_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_vertex);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_vertex_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_vertex_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->vertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_vertex_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_faces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_num_faces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_faces_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_num_faces_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_faces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_faces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_faces_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_faces);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_faces_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_faces_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_faces_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_faces_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->faces = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_faces_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_faces_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL *) ((arg1)->faces);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_num_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_edges_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_num_edges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_edges_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_edges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  Dwg_MESH_edge *arg2 = (Dwg_MESH_edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_edges_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_MESH_edge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_edges_set" "', argument " "2"" of type '" "Dwg_MESH_edge *""'"); 
  }
  arg2 = (Dwg_MESH_edge *)(argp2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_MESH_edge *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_edges_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (Dwg_MESH_edge *) ((arg1)->edges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_MESH_edge, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_crease_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_num_crease_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_crease_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_num_crease_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_crease = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_num_crease_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_num_crease_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_crease);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_crease_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_crease_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_crease_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_MESH_crease_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->crease = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_crease_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_crease_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_BD *) ((arg1)->crease);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_unknown_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_unknown_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_unknown_b1_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_unknown_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_unknown_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_unknown_b1_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_unknown_b2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_MESH_unknown_b2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_unknown_b2_set" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_MESH_unknown_b2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_MESH_unknown_b2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_MESH_unknown_b2_get" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_MESH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_MESH *)calloc(1, sizeof(struct _dwg_entity_MESH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MESH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_MESH *arg1 = (struct _dwg_entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_MESH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_MESH" "', argument " "1"" of type '" "struct _dwg_entity_MESH *""'"); 
  }
  arg1 = (struct _dwg_entity_MESH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_MESH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_MESH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_MESH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUN_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_is_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_is_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_is_on_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_is_on_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_is_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_is_on_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_B) ((arg1)->is_on);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_color_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUN_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_color_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_intensity_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_intensity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_intensity_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BD) ((arg1)->intensity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_has_shadow_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_has_shadow_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_has_shadow_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_has_shadow_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_shadow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_has_shadow_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_has_shadow_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_B) ((arg1)->has_shadow);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_julian_day_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_julian_day_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_julian_day_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_julian_day_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->julian_day = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_julian_day_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_julian_day_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BL) ((arg1)->julian_day);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_msecs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_msecs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_msecs_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_msecs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->msecs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_msecs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_msecs_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BL) ((arg1)->msecs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_is_dst_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_is_dst_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_is_dst_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_is_dst_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_dst = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_is_dst_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_is_dst_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_B) ((arg1)->is_dst);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_shadow_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_type_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_shadow_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shadow_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_type_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BL) ((arg1)->shadow_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_mapsize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_shadow_mapsize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_mapsize_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_shadow_mapsize_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadow_mapsize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_mapsize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_mapsize_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadow_mapsize);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_softness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUN_shadow_softness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_softness_set" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUN_shadow_softness_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->shadow_softness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUN_shadow_softness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUN_shadow_softness_get" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  result = (BITCODE_RC) ((arg1)->shadow_softness);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SUN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SUN", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SUN *)calloc(1, sizeof(struct _dwg_object_SUN));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SUN, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SUN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUN *arg1 = (struct _dwg_object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUN, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SUN" "', argument " "1"" of type '" "struct _dwg_object_SUN *""'"); 
  }
  arg1 = (struct _dwg_object_SUN *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SUN_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SUN, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SUN_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SUNSTUDY_Dates_julian_day_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *arg1 = (struct _dwg_SUNSTUDY_Dates *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SUNSTUDY_Dates_julian_day_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SUNSTUDY_Dates, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SUNSTUDY_Dates_julian_day_set" "', argument " "1"" of type '" "struct _dwg_SUNSTUDY_Dates *""'"); 
  }
  arg1 = (struct _dwg_SUNSTUDY_Dates *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SUNSTUDY_Dates_julian_day_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->julian_day = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SUNSTUDY_Dates_julian_day_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *arg1 = (struct _dwg_SUNSTUDY_Dates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SUNSTUDY_Dates, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SUNSTUDY_Dates_julian_day_get" "', argument " "1"" of type '" "struct _dwg_SUNSTUDY_Dates *""'"); 
  }
  arg1 = (struct _dwg_SUNSTUDY_Dates *)(argp1);
  result = (BITCODE_BL) ((arg1)->julian_day);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SUNSTUDY_Dates_msecs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *arg1 = (struct _dwg_SUNSTUDY_Dates *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SUNSTUDY_Dates_msecs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SUNSTUDY_Dates, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SUNSTUDY_Dates_msecs_set" "', argument " "1"" of type '" "struct _dwg_SUNSTUDY_Dates *""'"); 
  }
  arg1 = (struct _dwg_SUNSTUDY_Dates *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SUNSTUDY_Dates_msecs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->msecs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SUNSTUDY_Dates_msecs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *arg1 = (struct _dwg_SUNSTUDY_Dates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SUNSTUDY_Dates, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SUNSTUDY_Dates_msecs_get" "', argument " "1"" of type '" "struct _dwg_SUNSTUDY_Dates *""'"); 
  }
  arg1 = (struct _dwg_SUNSTUDY_Dates *)(argp1);
  result = (BITCODE_BL) ((arg1)->msecs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SUNSTUDY_Dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SUNSTUDY_Dates", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_SUNSTUDY_Dates *)calloc(1, sizeof(struct _dwg_SUNSTUDY_Dates));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SUNSTUDY_Dates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SUNSTUDY_Dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SUNSTUDY_Dates *arg1 = (struct _dwg_SUNSTUDY_Dates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SUNSTUDY_Dates, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SUNSTUDY_Dates" "', argument " "1"" of type '" "struct _dwg_SUNSTUDY_Dates *""'"); 
  }
  arg1 = (struct _dwg_SUNSTUDY_Dates *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SUNSTUDY_Dates_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_SUNSTUDY_Dates, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SUNSTUDY_Dates_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_setup_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_setup_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_setup_name_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_setup_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->setup_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->setup_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->setup_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_setup_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_setup_name_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_TV) ((arg1)->setup_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_description_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_description_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_output_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_output_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_output_type_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_output_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->output_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_output_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_output_type_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->output_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_sheet_set_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_sheet_set_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_sheet_set_name_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_sheet_set_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->sheet_set_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->sheet_set_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->sheet_set_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_sheet_set_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_sheet_set_name_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_TV) ((arg1)->sheet_set_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_use_subset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_use_subset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_use_subset_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_use_subset_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_subset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_use_subset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_use_subset_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B) ((arg1)->use_subset);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_sheet_subset_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_sheet_subset_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_sheet_subset_name_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_sheet_subset_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->sheet_subset_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->sheet_subset_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->sheet_subset_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_sheet_subset_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_sheet_subset_name_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_TV) ((arg1)->sheet_subset_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_select_dates_from_calendar_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_select_dates_from_calendar_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_select_dates_from_calendar_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_select_dates_from_calendar_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->select_dates_from_calendar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_select_dates_from_calendar_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_select_dates_from_calendar_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B) ((arg1)->select_dates_from_calendar);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_num_dates_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_num_dates_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_num_dates_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_num_dates_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_dates = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_num_dates_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_num_dates_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_dates);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_dates_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  Dwg_SUNSTUDY_Dates *arg2 = (Dwg_SUNSTUDY_Dates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_dates_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_dates_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SUNSTUDY_Dates, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_dates_set" "', argument " "2"" of type '" "Dwg_SUNSTUDY_Dates *""'"); 
  }
  arg2 = (Dwg_SUNSTUDY_Dates *)(argp2);
  if (arg1) (arg1)->dates = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_dates_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SUNSTUDY_Dates *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_dates_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (Dwg_SUNSTUDY_Dates *) ((arg1)->dates);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SUNSTUDY_Dates, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_select_range_of_dates_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_select_range_of_dates_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_select_range_of_dates_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_select_range_of_dates_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->select_range_of_dates = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_select_range_of_dates_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_select_range_of_dates_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B) ((arg1)->select_range_of_dates);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_start_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_start_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_start_time_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_start_time_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->start_time = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_start_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_start_time_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->start_time);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_end_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_end_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_end_time_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_end_time_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_time = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_end_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_end_time_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_time);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_interval_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_interval_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_interval_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_interval_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->interval = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_interval_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_interval_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->interval);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_num_hours_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_num_hours_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_num_hours_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_num_hours_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_hours = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_num_hours_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_num_hours_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_hours);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_hours_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B *arg2 = (BITCODE_B *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_hours_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_hours_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_hours_set" "', argument " "2"" of type '" "BITCODE_B *""'"); 
  }
  arg2 = (BITCODE_B *)(argp2);
  if (arg1) (arg1)->hours = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_hours_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_hours_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B *) ((arg1)->hours);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_shade_plot_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_shade_plot_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_shade_plot_type_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_shade_plot_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shade_plot_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_shade_plot_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_shade_plot_type_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->shade_plot_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numvports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_numvports_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numvports_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_numvports_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numvports = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numvports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numvports_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numvports);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numrows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_numrows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numrows_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_numrows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numrows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numrows_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numrows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numcols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_numcols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numcols_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_numcols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numcols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_numcols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_numcols_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BL) ((arg1)->numcols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_spacing_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_spacing_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_BD) ((arg1)->spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_lock_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_lock_viewports_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_lock_viewports_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_lock_viewports_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->lock_viewports = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_lock_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_lock_viewports_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B) ((arg1)->lock_viewports);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_label_viewports_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_label_viewports_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_label_viewports_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SUNSTUDY_label_viewports_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->label_viewports = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_label_viewports_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_label_viewports_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_B) ((arg1)->label_viewports);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_page_setup_wizard_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_page_setup_wizard_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_page_setup_wizard_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_page_setup_wizard_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->page_setup_wizard = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_page_setup_wizard_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_page_setup_wizard_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_H) ((arg1)->page_setup_wizard);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_view_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_view_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_view_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_view_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->view = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_view_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_view_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_H) ((arg1)->view);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_H) ((arg1)->visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SUNSTUDY_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_text_style_set" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SUNSTUDY_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SUNSTUDY_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SUNSTUDY_text_style_get" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  result = (BITCODE_H) ((arg1)->text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SUNSTUDY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SUNSTUDY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SUNSTUDY *)calloc(1, sizeof(struct _dwg_object_SUNSTUDY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SUNSTUDY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SUNSTUDY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SUNSTUDY *arg1 = (struct _dwg_object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SUNSTUDY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SUNSTUDY" "', argument " "1"" of type '" "struct _dwg_object_SUNSTUDY *""'"); 
  }
  arg1 = (struct _dwg_object_SUNSTUDY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SUNSTUDY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SUNSTUDY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SUNSTUDY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_row_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *arg1 = (struct _dwg_DATATABLE_row *) 0 ;
  struct _dwg_DATATABLE_column *arg2 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_row_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_row_parent_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_row *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_row *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DATATABLE_column, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATATABLE_row_parent_set" "', argument " "2"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg2 = (struct _dwg_DATATABLE_column *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_row_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *arg1 = (struct _dwg_DATATABLE_row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_DATATABLE_column *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_row_parent_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_row *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_row *)(argp1);
  result = (struct _dwg_DATATABLE_column *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_row_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *arg1 = (struct _dwg_DATATABLE_row *) 0 ;
  Dwg_TABLE_value *arg2 = (Dwg_TABLE_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_row_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_row_value_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_row *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_row *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATATABLE_row_value_set" "', argument " "2"" of type '" "Dwg_TABLE_value *""'"); 
  }
  arg2 = (Dwg_TABLE_value *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_row_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *arg1 = (struct _dwg_DATATABLE_row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_TABLE_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_row_value_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_row *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_row *)(argp1);
  result = (Dwg_TABLE_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_TABLE_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DATATABLE_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DATATABLE_row", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_DATATABLE_row *)calloc(1, sizeof(struct _dwg_DATATABLE_row));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATATABLE_row, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DATATABLE_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_row *arg1 = (struct _dwg_DATATABLE_row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_row, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DATATABLE_row" "', argument " "1"" of type '" "struct _dwg_DATATABLE_row *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_row *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DATATABLE_row_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_DATATABLE_row, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DATATABLE_row_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  struct _dwg_object_DATATABLE *arg2 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_column_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_parent_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DATATABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATATABLE_column_parent_set" "', argument " "2"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg2 = (struct _dwg_object_DATATABLE *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_DATATABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_parent_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  result = (struct _dwg_object_DATATABLE *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_column_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_type_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DATATABLE_column_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_type_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  result = (BITCODE_BL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_column_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_text_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATATABLE_column_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_text_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  Dwg_DATATABLE_row *arg2 = (Dwg_DATATABLE_row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATATABLE_column_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_rows_set" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DATATABLE_row, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATATABLE_column_rows_set" "', argument " "2"" of type '" "Dwg_DATATABLE_row *""'"); 
  }
  arg2 = (Dwg_DATATABLE_row *)(argp2);
  if (arg1) (arg1)->rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATATABLE_column_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DATATABLE_row *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATATABLE_column_rows_get" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  result = (Dwg_DATATABLE_row *) ((arg1)->rows);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATATABLE_row, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DATATABLE_column(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DATATABLE_column", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_DATATABLE_column *)calloc(1, sizeof(struct _dwg_DATATABLE_column));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATATABLE_column, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DATATABLE_column(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATATABLE_column *arg1 = (struct _dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATATABLE_column, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DATATABLE_column" "', argument " "1"" of type '" "struct _dwg_DATATABLE_column *""'"); 
  }
  arg1 = (struct _dwg_DATATABLE_column *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DATATABLE_column_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_DATATABLE_column, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DATATABLE_column_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATATABLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_flags_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATATABLE_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_flags_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_num_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_num_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_num_cols_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATATABLE_num_cols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_num_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_num_cols_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_cols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_num_rows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_num_rows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_num_rows_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATATABLE_num_rows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_rows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_num_rows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_num_rows_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_rows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_table_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_table_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_table_name_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATATABLE_table_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->table_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->table_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->table_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_table_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_table_name_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->table_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_cols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  Dwg_DATATABLE_column *arg2 = (Dwg_DATATABLE_column *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATATABLE_cols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_cols_set" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DATATABLE_column, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATATABLE_cols_set" "', argument " "2"" of type '" "Dwg_DATATABLE_column *""'"); 
  }
  arg2 = (Dwg_DATATABLE_column *)(argp2);
  if (arg1) (arg1)->cols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATATABLE_cols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DATATABLE_column *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATATABLE_cols_get" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  result = (Dwg_DATATABLE_column *) ((arg1)->cols);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATATABLE_column, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DATATABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DATATABLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DATATABLE *)calloc(1, sizeof(struct _dwg_object_DATATABLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATATABLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DATATABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATATABLE *arg1 = (struct _dwg_object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATATABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DATATABLE" "', argument " "1"" of type '" "struct _dwg_object_DATATABLE *""'"); 
  }
  arg1 = (struct _dwg_object_DATATABLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DATATABLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DATATABLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DATATABLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  struct _dwg_object_DATALINK *arg2 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATALINK_customdata_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_parent_set" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DATALINK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATALINK_customdata_parent_set" "', argument " "2"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg2 = (struct _dwg_object_DATALINK *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_DATALINK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_parent_get" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  result = (struct _dwg_object_DATALINK *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATALINK_customdata_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_target_set" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATALINK_customdata_target_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->target = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_target_get" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  result = (BITCODE_H) ((arg1)->target);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DATALINK_customdata_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_text_set" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DATALINK_customdata_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DATALINK_customdata_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DATALINK_customdata_text_get" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DATALINK_customdata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DATALINK_customdata", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_DATALINK_customdata *)calloc(1, sizeof(struct _dwg_DATALINK_customdata));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATALINK_customdata, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DATALINK_customdata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DATALINK_customdata *arg1 = (struct _dwg_DATALINK_customdata *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DATALINK_customdata, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DATALINK_customdata" "', argument " "1"" of type '" "struct _dwg_DATALINK_customdata *""'"); 
  }
  arg1 = (struct _dwg_DATALINK_customdata *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DATALINK_customdata_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_DATALINK_customdata, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DATALINK_customdata_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_data_adapter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_data_adapter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_data_adapter_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_data_adapter_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->data_adapter);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->data_adapter = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->data_adapter = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_data_adapter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_data_adapter_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_TV) ((arg1)->data_adapter);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_description_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_description_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_tooltip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_tooltip_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_tooltip_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_tooltip_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tooltip);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tooltip = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tooltip = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_tooltip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_tooltip_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_TV) ((arg1)->tooltip);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_connection_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_connection_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_connection_string_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_connection_string_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->connection_string);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->connection_string = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->connection_string = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_connection_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_connection_string_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_TV) ((arg1)->connection_string);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_option_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_option_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_option_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BL) ((arg1)->option);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_update_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_update_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_update_option_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_update_option_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->update_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_update_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_update_option_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BL) ((arg1)->update_option);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_year_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_year_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_year_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_year_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->year = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_year_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_year_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->year);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_month_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_month_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_month_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_month_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->month = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_month_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_month_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->month);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_day_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_day_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_day_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_day_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->day = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_day_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_day_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->day);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_hour_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_hour_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_hour_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_hour_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->hour = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_hour_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_hour_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->hour);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_minute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_minute_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_minute_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_minute_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->minute = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_minute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_minute_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->minute);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_seconds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_seconds_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_seconds_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_seconds_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->seconds = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_seconds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_seconds_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->seconds);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_msec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_msec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_msec_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_msec_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->msec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_msec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_msec_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->msec);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_path_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_path_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_path_option_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_path_option_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->path_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_path_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_path_option_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BS) ((arg1)->path_option);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_bl93_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_bl93_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_bl93_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_bl93_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl93 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_bl93_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_bl93_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl93);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_update_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_update_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_update_status_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_update_status_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->update_status);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->update_status = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->update_status = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_update_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_update_status_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_TV) ((arg1)->update_status);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_num_customdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_num_customdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_num_customdata_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DATALINK_num_customdata_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_customdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_num_customdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_num_customdata_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_customdata);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_customdata_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  Dwg_DATALINK_customdata *arg2 = (Dwg_DATALINK_customdata *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_customdata_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_customdata_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DATALINK_customdata, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_customdata_set" "', argument " "2"" of type '" "Dwg_DATALINK_customdata *""'"); 
  }
  arg2 = (Dwg_DATALINK_customdata *)(argp2);
  if (arg1) (arg1)->customdata = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_customdata_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DATALINK_customdata *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_customdata_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (Dwg_DATALINK_customdata *) ((arg1)->customdata);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DATALINK_customdata, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_hardowner_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DATALINK_hardowner_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_hardowner_set" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DATALINK_hardowner_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->hardowner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DATALINK_hardowner_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DATALINK_hardowner_get" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  result = (BITCODE_H) ((arg1)->hardowner);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DATALINK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DATALINK", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DATALINK *)calloc(1, sizeof(struct _dwg_object_DATALINK));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATALINK, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DATALINK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DATALINK *arg1 = (struct _dwg_object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DATALINK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DATALINK" "', argument " "1"" of type '" "struct _dwg_object_DATALINK *""'"); 
  }
  arg1 = (struct _dwg_object_DATALINK *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DATALINK_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DATALINK, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DATALINK_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  struct _dwg_object_DIMASSOC *arg2 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_parent_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DIMASSOC, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_parent_set" "', argument " "2"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg2 = (struct _dwg_object_DIMASSOC *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_DIMASSOC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_parent_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (struct _dwg_object_DIMASSOC *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_classname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_classname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_classname_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_classname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->classname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->classname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->classname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_classname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_classname_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_TV) ((arg1)->classname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_osnap_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_type_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_osnap_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->osnap_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_type_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_RC) ((arg1)->osnap_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_osnap_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_dist_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_osnap_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->osnap_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_dist_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BD) ((arg1)->osnap_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_osnap_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_pt_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_osnap_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->osnap_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_osnap_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_osnap_pt_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->osnap_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_xrefs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_num_xrefs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_xrefs_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_num_xrefs_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_xrefs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_xrefs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_xrefs_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_xrefs);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_xrefs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_xrefs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_xrefs_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_xrefs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->xrefs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_xrefs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_xrefs_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_H *) ((arg1)->xrefs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_main_subent_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_main_subent_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_main_subent_type_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_main_subent_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->main_subent_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_main_subent_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_main_subent_type_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BS) ((arg1)->main_subent_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_main_gsmarker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_main_gsmarker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_main_gsmarker_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_main_gsmarker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->main_gsmarker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_main_gsmarker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_main_gsmarker_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BL) ((arg1)->main_gsmarker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_xrefpaths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_num_xrefpaths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_xrefpaths_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_num_xrefpaths_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_xrefpaths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_xrefpaths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_xrefpaths_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_xrefpaths);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_xrefpaths_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_xrefpaths_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_xrefpaths_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_xrefpaths_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->xrefpaths = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_xrefpaths_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_xrefpaths_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_TV *) ((arg1)->xrefpaths);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_has_lastpt_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_has_lastpt_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_has_lastpt_ref_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_has_lastpt_ref_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_lastpt_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_has_lastpt_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_has_lastpt_ref_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_B) ((arg1)->has_lastpt_ref);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_lastpt_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_lastpt_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_lastpt_ref_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_lastpt_ref_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->lastpt_ref = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_lastpt_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_lastpt_ref_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->lastpt_ref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_intsectobj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_num_intsectobj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_intsectobj_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_DIMASSOC_Ref_num_intsectobj_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_intsectobj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_num_intsectobj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_num_intsectobj_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_intsectobj);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_intsectobj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_DIMASSOC_Ref_intsectobj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_intsectobj_set" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_DIMASSOC_Ref_intsectobj_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->intsectobj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DIMASSOC_Ref_intsectobj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DIMASSOC_Ref_intsectobj_get" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  result = (BITCODE_H *) ((arg1)->intsectobj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DIMASSOC_Ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DIMASSOC_Ref", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_DIMASSOC_Ref *)calloc(1, sizeof(struct _dwg_DIMASSOC_Ref));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DIMASSOC_Ref, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DIMASSOC_Ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_DIMASSOC_Ref *arg1 = (struct _dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_DIMASSOC_Ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DIMASSOC_Ref" "', argument " "1"" of type '" "struct _dwg_DIMASSOC_Ref *""'"); 
  }
  arg1 = (struct _dwg_DIMASSOC_Ref *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DIMASSOC_Ref_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_DIMASSOC_Ref, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DIMASSOC_Ref_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMASSOC_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_dimensionobj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_dimensionobj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_dimensionobj_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMASSOC_dimensionobj_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimensionobj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_dimensionobj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_dimensionobj_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (BITCODE_H) ((arg1)->dimensionobj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_associativity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_associativity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_associativity_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMASSOC_associativity_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->associativity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_associativity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_associativity_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (BITCODE_BL) ((arg1)->associativity);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_trans_space_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_trans_space_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_trans_space_flag_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMASSOC_trans_space_flag_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->trans_space_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_trans_space_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_trans_space_flag_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (BITCODE_B) ((arg1)->trans_space_flag);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_rotated_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_rotated_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_rotated_type_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DIMASSOC_rotated_type_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->rotated_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_rotated_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_rotated_type_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (BITCODE_RC) ((arg1)->rotated_type);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  Dwg_DIMASSOC_Ref *arg2 = (Dwg_DIMASSOC_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DIMASSOC_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_ref_set" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DIMASSOC_Ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DIMASSOC_ref_set" "', argument " "2"" of type '" "Dwg_DIMASSOC_Ref *""'"); 
  }
  arg2 = (Dwg_DIMASSOC_Ref *)(argp2);
  if (arg1) (arg1)->ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DIMASSOC_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DIMASSOC_Ref *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DIMASSOC_ref_get" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  result = (Dwg_DIMASSOC_Ref *) ((arg1)->ref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DIMASSOC_Ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DIMASSOC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DIMASSOC", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DIMASSOC *)calloc(1, sizeof(struct _dwg_object_DIMASSOC));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMASSOC, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DIMASSOC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DIMASSOC *arg1 = (struct _dwg_object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DIMASSOC, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DIMASSOC" "', argument " "1"" of type '" "struct _dwg_object_DIMASSOC *""'"); 
  }
  arg1 = (struct _dwg_object_DIMASSOC *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DIMASSOC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DIMASSOC, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DIMASSOC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  struct _dwg_object_ASSOCNETWORK *arg2 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCNETWORK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg2 = (struct _dwg_object_ASSOCNETWORK *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_ASSOCNETWORK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  result = (struct _dwg_object_ASSOCNETWORK *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_evaluatorid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACTIONBODY_evaluatorid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_evaluatorid_set" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACTIONBODY_evaluatorid_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->evaluatorid);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->evaluatorid = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->evaluatorid = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_evaluatorid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_evaluatorid_get" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->evaluatorid);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_expression_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACTIONBODY_expression_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_expression_set" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACTIONBODY_expression_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expression);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expression = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expression = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_expression_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_expression_get" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->expression);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACTIONBODY_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_value_set" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACTIONBODY_value_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACTIONBODY_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACTIONBODY_value_get" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->value);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ACTIONBODY *)calloc(1, sizeof(struct _dwg_ACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACTIONBODY *arg1 = (struct _dwg_ACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ACTIONBODY" "', argument " "1"" of type '" "struct _dwg_ACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_EvalVariant_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalVariant *arg1 = (struct _dwg_EvalVariant *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalVariant_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalVariant_code_set" "', argument " "1"" of type '" "struct _dwg_EvalVariant *""'"); 
  }
  arg1 = (struct _dwg_EvalVariant *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalVariant_code_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalVariant_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalVariant *arg1 = (struct _dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalVariant_code_get" "', argument " "1"" of type '" "struct _dwg_EvalVariant *""'"); 
  }
  arg1 = (struct _dwg_EvalVariant *)(argp1);
  result = (BITCODE_BS) ((arg1)->code);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalVariant_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalVariant *arg1 = (struct _dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_EvalVariant_u *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalVariant_u_get" "', argument " "1"" of type '" "struct _dwg_EvalVariant *""'"); 
  }
  arg1 = (struct _dwg_EvalVariant *)(argp1);
  result = (_dwg_EvalVariant_u *)& ((arg1)->u);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_EvalVariant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalVariant *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_EvalVariant", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_EvalVariant *)calloc(1, sizeof(struct _dwg_EvalVariant));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_EvalVariant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalVariant *arg1 = (struct _dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_EvalVariant" "', argument " "1"" of type '" "struct _dwg_EvalVariant *""'"); 
  }
  arg1 = (struct _dwg_EvalVariant *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_EvalVariant_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EvalVariant, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_EvalVariant_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_bd_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bd_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalVariant_u_bd_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bd_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_bl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bl_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalVariant_u_bl_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bl_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_bs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bs_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalVariant_u_bs_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_bs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_bs_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_rc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_rc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_rc_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalVariant_u_rc_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->rc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_rc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_rc_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_RC) ((arg1)->rc);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_text_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalVariant_u_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_text_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalVariant_u_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_handle_set" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalVariant_u_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalVariant_u_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalVariant_u_handle_get" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_EvalVariant_u(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_EvalVariant_u", 0, 0, 0)) SWIG_fail;
  result = (_dwg_EvalVariant_u *)calloc(1, sizeof(_dwg_EvalVariant_u));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant_u, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_EvalVariant_u(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalVariant_u *arg1 = (_dwg_EvalVariant_u *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalVariant_u, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_EvalVariant_u" "', argument " "1"" of type '" "_dwg_EvalVariant_u *""'"); 
  }
  arg1 = (_dwg_EvalVariant_u *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_EvalVariant_u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EvalVariant_u, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_EvalVariant_u_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *arg1 = (struct _dwg_VALUEPARAM_vars *) 0 ;
  Dwg_EvalVariant *arg2 = (Dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_vars_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM_vars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_value_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM_vars *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM_vars *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_vars_value_set" "', argument " "2"" of type '" "Dwg_EvalVariant *""'"); 
  }
  arg2 = (Dwg_EvalVariant *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *arg1 = (struct _dwg_VALUEPARAM_vars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalVariant *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM_vars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_value_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM_vars *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM_vars *)(argp1);
  result = (Dwg_EvalVariant *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *arg1 = (struct _dwg_VALUEPARAM_vars *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_vars_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM_vars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_handle_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM_vars *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM_vars *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_vars_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *arg1 = (struct _dwg_VALUEPARAM_vars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM_vars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_handle_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM_vars *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM_vars *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_VALUEPARAM_vars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_VALUEPARAM_vars", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_VALUEPARAM_vars *)calloc(1, sizeof(struct _dwg_VALUEPARAM_vars));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM_vars, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_VALUEPARAM_vars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM_vars *arg1 = (struct _dwg_VALUEPARAM_vars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM_vars, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_VALUEPARAM_vars" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM_vars *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM_vars *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_VALUEPARAM_vars_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_VALUEPARAM_vars, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_VALUEPARAM_vars_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_VALUEPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_unit_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_unit_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_unit_type_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_VALUEPARAM_unit_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unit_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_unit_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_unit_type_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->unit_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_num_vars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_num_vars_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_num_vars_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_VALUEPARAM_num_vars_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_vars = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_num_vars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_num_vars_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_vars);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  Dwg_VALUEPARAM_vars *arg2 = (Dwg_VALUEPARAM_vars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_vars_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM_vars, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_vars_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM_vars *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM_vars *)(argp2);
  if (arg1) (arg1)->vars = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_vars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM_vars *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_vars_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (Dwg_VALUEPARAM_vars *) ((arg1)->vars);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM_vars, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_controlled_objdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VALUEPARAM_controlled_objdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_controlled_objdep_set" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VALUEPARAM_controlled_objdep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->controlled_objdep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VALUEPARAM_controlled_objdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VALUEPARAM_controlled_objdep_get" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->controlled_objdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_VALUEPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_VALUEPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_VALUEPARAM *)calloc(1, sizeof(struct _dwg_VALUEPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_VALUEPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_VALUEPARAM *arg1 = (struct _dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_VALUEPARAM" "', argument " "1"" of type '" "struct _dwg_VALUEPARAM *""'"); 
  }
  arg1 = (struct _dwg_VALUEPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_VALUEPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_VALUEPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_VALUEPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_version_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_version_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->l4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->l4);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->l5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->l5);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assocdep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assocdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  Dwg_VALUEPARAM *arg2 = (Dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCPARAMBASEDACTIONBODY_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_values_set" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_values_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCPARAMBASEDACTIONBODY_values_get" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  result = (Dwg_VALUEPARAM *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ASSOCPARAMBASEDACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ASSOCPARAMBASEDACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)calloc(1, sizeof(struct _dwg_ASSOCPARAMBASEDACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ASSOCPARAMBASEDACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCPARAMBASEDACTIONBODY *arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ASSOCPARAMBASEDACTIONBODY" "', argument " "1"" of type '" "struct _dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCPARAMBASEDACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ASSOCPARAMBASEDACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ASSOCPARAMBASEDACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  struct _dwg_object_ASSOCACTION *arg2 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTION_Deps_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_parent_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCACTION_Deps_parent_set" "', argument " "2"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg2 = (struct _dwg_object_ASSOCACTION *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_ASSOCACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_parent_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  result = (struct _dwg_object_ASSOCACTION *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_is_owned_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTION_Deps_is_owned_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_is_owned_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCACTION_Deps_is_owned_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_owned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_is_owned_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_is_owned_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  result = (BITCODE_B) ((arg1)->is_owned);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTION_Deps_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_dep_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCACTION_Deps_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTION_Deps_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTION_Deps_dep_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ASSOCACTION_Deps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ASSOCACTION_Deps", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ASSOCACTION_Deps *)calloc(1, sizeof(struct _dwg_ASSOCACTION_Deps));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ASSOCACTION_Deps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTION_Deps *arg1 = (struct _dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ASSOCACTION_Deps" "', argument " "1"" of type '" "struct _dwg_ASSOCACTION_Deps *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTION_Deps *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ASSOCACTION_Deps_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ASSOCACTION_Deps_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_BL) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_read_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_read_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_read_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_write_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_write_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_write_dep);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_attached_to_object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_attached_to_object);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_delegating_to_owning_action = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_delegating_to_owning_action);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_order_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_order_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_order_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_BLd) ((arg1)->order);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_dep_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_dep_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_on_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_on_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep_on = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_dep_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_on_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_H) ((arg1)->dep_on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_has_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_has_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_has_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_has_name_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_name = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_has_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_has_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->has_name);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_depbodyid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_depbodyid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_depbodyid_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_depbodyid_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->depbodyid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_depbodyid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_depbodyid_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_BLd) ((arg1)->depbodyid);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_readdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_readdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_readdep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_readdep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->readdep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_readdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_readdep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_H) ((arg1)->readdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_dep_body_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_dep_body_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_body_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_body_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep_body = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_dep_body_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_dep_body_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_H) ((arg1)->dep_body);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDEPENDENCY_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDEPENDENCY_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDEPENDENCY_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDEPENDENCY_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  result = (BITCODE_H) ((arg1)->node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCDEPENDENCY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCDEPENDENCY *)calloc(1, sizeof(struct _dwg_object_ASSOCDEPENDENCY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDEPENDENCY *arg1 = (struct _dwg_object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCDEPENDENCY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDEPENDENCY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCDEPENDENCY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCDEPENDENCY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *) 0 ;
  Dwg_Object_ASSOCDEPENDENCY *arg2 = (Dwg_Object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCDEPENDENCY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCDEPENDENCY *)(argp2);
  if (arg1) (arg1)->assocdep = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)(argp1);
  result = (Dwg_Object_ASSOCDEPENDENCY *)& ((arg1)->assocdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCVALUEDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCVALUEDEPENDENCY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)calloc(1, sizeof(struct _dwg_object_ASSOCVALUEDEPENDENCY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCVALUEDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVALUEDEPENDENCY *arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCVALUEDEPENDENCY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVALUEDEPENDENCY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCVALUEDEPENDENCY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCVALUEDEPENDENCY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  Dwg_Object_ASSOCDEPENDENCY *arg2 = (Dwg_Object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCDEPENDENCY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCDEPENDENCY *)(argp2);
  if (arg1) (arg1)->assocdep = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (Dwg_Object_ASSOCDEPENDENCY *)& ((arg1)->assocdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->classname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->classname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->classname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_classname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (BITCODE_TV) ((arg1)->classname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dependent_on_compound_object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  result = (BITCODE_B) ((arg1)->dependent_on_compound_object);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCGEOMDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCGEOMDEPENDENCY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)calloc(1, sizeof(struct _dwg_object_ASSOCGEOMDEPENDENCY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCGEOMDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCGEOMDEPENDENCY *arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCGEOMDEPENDENCY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCGEOMDEPENDENCY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCGEOMDEPENDENCY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCGEOMDEPENDENCY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_geometry_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_geometry_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_geometry_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_geometry_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geometry_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_geometry_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_geometry_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->geometry_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_owningnetwork_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_owningnetwork_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_owningnetwork_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_owningnetwork_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->owningnetwork = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_owningnetwork_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_owningnetwork_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_H) ((arg1)->owningnetwork);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_action_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_action_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_action_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_action_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->action_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_action_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_action_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->action_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_max_assoc_dep_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_max_assoc_dep_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_max_assoc_dep_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_max_assoc_dep_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->max_assoc_dep_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_max_assoc_dep_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_max_assoc_dep_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->max_assoc_dep_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  Dwg_ASSOCACTION_Deps *arg2 = (Dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_deps_set" "', argument " "2"" of type '" "Dwg_ASSOCACTION_Deps *""'"); 
  }
  arg2 = (Dwg_ASSOCACTION_Deps *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (Dwg_ASSOCACTION_Deps *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_num_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_num_owned_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_owned_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->owned_params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTION_num_values_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_num_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  Dwg_VALUEPARAM *arg2 = (Dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTION_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTION_values_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTION_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTION_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  result = (Dwg_VALUEPARAM *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCACTION *)calloc(1, sizeof(struct _dwg_object_ASSOCACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTION *arg1 = (struct _dwg_object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCACTION" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTION *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_geometry_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_geometry_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_geometry_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_geometry_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geometry_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_geometry_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_geometry_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->geometry_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owningnetwork_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_owningnetwork_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owningnetwork_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_owningnetwork_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->owningnetwork = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owningnetwork_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owningnetwork_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_H) ((arg1)->owningnetwork);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_action_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_action_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_action_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_action_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->action_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_action_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_action_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->action_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->max_assoc_dep_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->max_assoc_dep_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  Dwg_ASSOCACTION_Deps *arg2 = (Dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_deps_set" "', argument " "2"" of type '" "Dwg_ASSOCACTION_Deps *""'"); 
  }
  arg2 = (Dwg_ASSOCACTION_Deps *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (Dwg_ASSOCACTION_Deps *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_num_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_owned_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_H *) ((arg1)->owned_params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_num_values_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  Dwg_VALUEPARAM *arg2 = (Dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_values_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (Dwg_VALUEPARAM *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_network_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_network_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_network_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_network_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->network_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_network_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_network_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BS) ((arg1)->network_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_network_action_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_network_action_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_network_action_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_network_action_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->network_action_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_network_action_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_network_action_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->network_action_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  Dwg_ASSOCACTION_Deps *arg2 = (Dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_actions_set" "', argument " "2"" of type '" "Dwg_ASSOCACTION_Deps *""'"); 
  }
  arg2 = (Dwg_ASSOCACTION_Deps *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (Dwg_ASSOCACTION_Deps *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_owned_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_num_owned_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_num_owned_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_num_owned_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owned_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORK_owned_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owned_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORK_owned_actions_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->owned_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORK_owned_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORK_owned_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  result = (BITCODE_H *) ((arg1)->owned_actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCNETWORK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCNETWORK", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCNETWORK *)calloc(1, sizeof(struct _dwg_object_ASSOCNETWORK));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORK, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCNETWORK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORK *arg1 = (struct _dwg_object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCNETWORK" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORK *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORK *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCNETWORK_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCNETWORK, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCNETWORK_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg2 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONSTRAINTGROUPNODE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_parent_set" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONSTRAINTGROUPNODE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg2 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_parent_get" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  result = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_nodeid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONSTRAINTGROUPNODE_nodeid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_nodeid_set" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CONSTRAINTGROUPNODE_nodeid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->nodeid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_nodeid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_nodeid_get" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  result = (BITCODE_BL) ((arg1)->nodeid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONSTRAINTGROUPNODE_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_status_set" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CONSTRAINTGROUPNODE_status_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_status_get" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  result = (BITCODE_RC) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_num_connections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONSTRAINTGROUPNODE_num_connections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_num_connections_set" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CONSTRAINTGROUPNODE_num_connections_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_connections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_num_connections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_num_connections_get" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_connections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_connections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONSTRAINTGROUPNODE_connections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_connections_set" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONSTRAINTGROUPNODE_connections_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->connections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONSTRAINTGROUPNODE_connections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONSTRAINTGROUPNODE_connections_get" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  result = (BITCODE_BL *) ((arg1)->connections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_CONSTRAINTGROUPNODE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_CONSTRAINTGROUPNODE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_CONSTRAINTGROUPNODE *)calloc(1, sizeof(struct _dwg_CONSTRAINTGROUPNODE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_CONSTRAINTGROUPNODE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONSTRAINTGROUPNODE *arg1 = (struct _dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_CONSTRAINTGROUPNODE" "', argument " "1"" of type '" "struct _dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg1 = (struct _dwg_CONSTRAINTGROUPNODE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_CONSTRAINTGROUPNODE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_CONSTRAINTGROUPNODE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geometry_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->geometry_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->owningnetwork = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_H) ((arg1)->owningnetwork);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->action_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->action_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->max_assoc_dep_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->max_assoc_dep_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  Dwg_ASSOCACTION_Deps *arg2 = (Dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set" "', argument " "2"" of type '" "Dwg_ASSOCACTION_Deps *""'"); 
  }
  arg2 = (Dwg_ASSOCACTION_Deps *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (Dwg_ASSOCACTION_Deps *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_H *) ((arg1)->owned_params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  Dwg_VALUEPARAM *arg2 = (Dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (Dwg_VALUEPARAM *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_B) ((arg1)->b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) (BITCODE_3BD *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set" "', argument " "2"" of type '" "BITCODE_3BD [3]""'"); 
  } 
  arg2 = (BITCODE_3BD *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(BITCODE_3BD *)&arg1->workplane[ii] = *((BITCODE_3BD *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""workplane""' of type '""BITCODE_3BD [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_3BD *)(BITCODE_3BD *) ((arg1)->workplane);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_H) ((arg1)->h1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_H *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_nodes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  Dwg_CONSTRAINTGROUPNODE *arg2 = (Dwg_CONSTRAINTGROUPNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set" "', argument " "2"" of type '" "Dwg_CONSTRAINTGROUPNODE *""'"); 
  }
  arg2 = (Dwg_CONSTRAINTGROUPNODE *)(argp2);
  if (arg1) (arg1)->nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CONSTRAINTGROUPNODE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  result = (Dwg_CONSTRAINTGROUPNODE *) ((arg1)->nodes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONSTRAINTGROUPNODE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOC2DCONSTRAINTGROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOC2DCONSTRAINTGROUP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)calloc(1, sizeof(struct _dwg_object_ASSOC2DCONSTRAINTGROUP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOC2DCONSTRAINTGROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC2DCONSTRAINTGROUP *arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOC2DCONSTRAINTGROUP" "', argument " "1"" of type '" "struct _dwg_object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC2DCONSTRAINTGROUP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOC2DCONSTRAINTGROUP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOC2DCONSTRAINTGROUP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_av_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_av_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_av_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_av_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->av_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_av_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_av_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->av_class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_geometry_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_geometry_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_geometry_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_geometry_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->geometry_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_geometry_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_geometry_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->geometry_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_owningnetwork_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_owningnetwork_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_owningnetwork_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_owningnetwork_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->owningnetwork = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_owningnetwork_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_owningnetwork_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->owningnetwork);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_action_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_action_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_action_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_action_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->action_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_action_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_action_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->action_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->max_assoc_dep_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->max_assoc_dep_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  Dwg_ASSOCACTION_Deps *arg2 = (Dwg_ASSOCACTION_Deps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_deps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTION_Deps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_deps_set" "', argument " "2"" of type '" "Dwg_ASSOCACTION_Deps *""'"); 
  }
  arg2 = (Dwg_ASSOCACTION_Deps *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTION_Deps *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_deps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (Dwg_ASSOCACTION_Deps *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTION_Deps, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_num_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_num_owned_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_owned_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_owned_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_owned_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_owned_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_owned_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->owned_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_owned_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_owned_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_H *) ((arg1)->owned_params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_num_values_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_num_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  Dwg_VALUEPARAM *arg2 = (Dwg_VALUEPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_values_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_VALUEPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_values_set" "', argument " "2"" of type '" "Dwg_VALUEPARAM *""'"); 
  }
  arg2 = (Dwg_VALUEPARAM *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VALUEPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_values_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (Dwg_VALUEPARAM *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_VALUEPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_t58_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_t58_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_t58_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_t58_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->t58);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->t58 = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->t58 = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_t58_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_t58_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->t58);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_evaluator_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_evaluator_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_evaluator_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_evaluator_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->evaluator);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->evaluator = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->evaluator = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_evaluator_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_evaluator_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->evaluator);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_desc_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_desc_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  Dwg_EvalVariant *arg2 = (Dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_value_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_value_set" "', argument " "2"" of type '" "Dwg_EvalVariant *""'"); 
  }
  arg2 = (Dwg_EvalVariant *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalVariant *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_value_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (Dwg_EvalVariant *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_has_t78_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_has_t78_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_has_t78_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_has_t78_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_t78 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_has_t78_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_has_t78_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->has_t78);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_t78_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_t78_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_t78_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVARIABLE_t78_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->t78);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->t78 = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->t78 = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_t78_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_t78_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->t78);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_b290_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVARIABLE_b290_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_b290_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVARIABLE_b290_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b290 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVARIABLE_b290_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVARIABLE_b290_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  result = (BITCODE_B) ((arg1)->b290);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCVARIABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCVARIABLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCVARIABLE *)calloc(1, sizeof(struct _dwg_object_ASSOCVARIABLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVARIABLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCVARIABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVARIABLE *arg1 = (struct _dwg_object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCVARIABLE" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVARIABLE *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVARIABLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCVARIABLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCVARIABLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCVARIABLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  struct _dwg_object_EVALUATION_GRAPH *arg2 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_parent_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_EVAL_Node_parent_set" "', argument " "2"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg2 = (struct _dwg_object_EVALUATION_GRAPH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_EVALUATION_GRAPH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_parent_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (struct _dwg_object_EVALUATION_GRAPH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_id_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Node_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_id_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_BL) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_edge_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_edge_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_edge_flags_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Node_edge_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->edge_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_edge_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_edge_flags_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_BL) ((arg1)->edge_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_nextid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_nextid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_nextid_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Node_nextid_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->nextid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_nextid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_nextid_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_BLd) ((arg1)->nextid);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_EVAL_Node_evalexpr_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->evalexpr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_H) ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_BLd *arg2 = (BITCODE_BLd *) (BITCODE_BLd *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_node_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_EVAL_Node_node_set" "', argument " "2"" of type '" "BITCODE_BLd [4]""'"); 
  } 
  arg2 = (BITCODE_BLd *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) *(BITCODE_BLd *)&arg1->node[ii] = *((BITCODE_BLd *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""node""' of type '""BITCODE_BLd [4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_node_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_BLd *)(BITCODE_BLd *) ((arg1)->node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_active_cycles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Node_active_cycles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_active_cycles_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Node_active_cycles_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->active_cycles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Node_active_cycles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Node_active_cycles_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  result = (BITCODE_B) ((arg1)->active_cycles);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_EVAL_Node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_EVAL_Node", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_EVAL_Node *)calloc(1, sizeof(struct _dwg_EVAL_Node));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EVAL_Node, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_EVAL_Node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Node *arg1 = (struct _dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_EVAL_Node" "', argument " "1"" of type '" "struct _dwg_EVAL_Node *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Node *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_EVAL_Node_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EVAL_Node, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_EVAL_Node_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  struct _dwg_object_EVALUATION_GRAPH *arg2 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_parent_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_EVAL_Edge_parent_set" "', argument " "2"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg2 = (struct _dwg_object_EVALUATION_GRAPH *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_EVALUATION_GRAPH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_parent_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (struct _dwg_object_EVALUATION_GRAPH *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_id_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Edge_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_id_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BL) ((arg1)->id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_nextid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_nextid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_nextid_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Edge_nextid_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->nextid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_nextid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_nextid_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BLd) ((arg1)->nextid);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_e1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e1_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Edge_e1_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->e1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e1_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BLd) ((arg1)->e1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_e2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e2_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Edge_e2_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->e2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e2_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BLd) ((arg1)->e2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_e3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e3_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EVAL_Edge_e3_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->e3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_e3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_e3_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BLd) ((arg1)->e3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_out_edge_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  BITCODE_BLd *arg2 = (BITCODE_BLd *) (BITCODE_BLd *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EVAL_Edge_out_edge_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_out_edge_set" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_EVAL_Edge_out_edge_set" "', argument " "2"" of type '" "BITCODE_BLd [5]""'"); 
  } 
  arg2 = (BITCODE_BLd *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)5; ++ii) *(BITCODE_BLd *)&arg1->out_edge[ii] = *((BITCODE_BLd *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""out_edge""' of type '""BITCODE_BLd [5]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EVAL_Edge_out_edge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EVAL_Edge_out_edge_get" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  result = (BITCODE_BLd *)(BITCODE_BLd *) ((arg1)->out_edge);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_EVAL_Edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_EVAL_Edge", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_EVAL_Edge *)calloc(1, sizeof(struct _dwg_EVAL_Edge));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EVAL_Edge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_EVAL_Edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EVAL_Edge *arg1 = (struct _dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EVAL_Edge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_EVAL_Edge" "', argument " "1"" of type '" "struct _dwg_EVAL_Edge *""'"); 
  }
  arg1 = (struct _dwg_EVAL_Edge *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_EVAL_Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EVAL_Edge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_EVAL_Edge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_parent_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_EVALUATION_GRAPH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_parent_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_major_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_major_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_minor_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_minor_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_first_nodeid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->first_nodeid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BLd) ((arg1)->first_nodeid);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->first_nodeid_copy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BLd) ((arg1)->first_nodeid_copy);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_num_nodes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_num_nodes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_nodes_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_nodes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_num_nodes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_nodes_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_nodes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_nodes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  Dwg_EVAL_Node *arg2 = (Dwg_EVAL_Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_nodes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_nodes_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EVAL_Node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_EVALUATION_GRAPH_nodes_set" "', argument " "2"" of type '" "Dwg_EVAL_Node *""'"); 
  }
  arg2 = (Dwg_EVAL_Node *)(argp2);
  if (arg1) (arg1)->nodes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_nodes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EVAL_Node *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_nodes_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (Dwg_EVAL_Node *) ((arg1)->nodes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EVAL_Node, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_has_graph_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_has_graph_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_has_graph_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_has_graph_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_graph = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_has_graph_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_has_graph_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_B) ((arg1)->has_graph);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_num_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_num_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_edges_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_edges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_num_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_num_edges_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_edges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  Dwg_EVAL_Edge *arg2 = (Dwg_EVAL_Edge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_EVALUATION_GRAPH_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_edges_set" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EVAL_Edge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_EVALUATION_GRAPH_edges_set" "', argument " "2"" of type '" "Dwg_EVAL_Edge *""'"); 
  }
  arg2 = (Dwg_EVAL_Edge *)(argp2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_EVALUATION_GRAPH_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EVAL_Edge *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_EVALUATION_GRAPH_edges_get" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  result = (Dwg_EVAL_Edge *) ((arg1)->edges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EVAL_Edge, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_EVALUATION_GRAPH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_EVALUATION_GRAPH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_EVALUATION_GRAPH *)calloc(1, sizeof(struct _dwg_object_EVALUATION_GRAPH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_EVALUATION_GRAPH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_EVALUATION_GRAPH *arg1 = (struct _dwg_object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_EVALUATION_GRAPH" "', argument " "1"" of type '" "struct _dwg_object_EVALUATION_GRAPH *""'"); 
  }
  arg1 = (struct _dwg_object_EVALUATION_GRAPH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_EVALUATION_GRAPH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_EVALUATION_GRAPH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_get" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_get" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)calloc(1, sizeof(struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PERSUBENTMGR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_unknown_0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_unknown_0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_0_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_0_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_unknown_0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_0_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_0);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_numassocsteps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_numassocsteps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsteps_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsteps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numassocsteps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_numassocsteps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsteps_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->numassocsteps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_numassocsubents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_numassocsubents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsubents_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsubents_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numassocsubents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_numassocsubents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_numassocsubents_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->numassocsubents);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_num_steps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_num_steps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_num_steps_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_num_steps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_steps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_num_steps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_num_steps_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_steps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_steps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_steps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_steps_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PERSUBENTMGR_steps_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->steps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_steps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_steps_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL *) ((arg1)->steps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_num_subents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_num_subents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_num_subents_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PERSUBENTMGR_num_subents_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_subents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_num_subents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_num_subents_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_subents);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_subents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PERSUBENTMGR_subents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_subents_set" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PERSUBENTMGR_subents_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->subents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PERSUBENTMGR_subents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PERSUBENTMGR_subents_get" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  result = (BITCODE_BL *) ((arg1)->subents);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_PERSUBENTMGR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_PERSUBENTMGR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_PERSUBENTMGR *)calloc(1, sizeof(struct _dwg_object_PERSUBENTMGR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PERSUBENTMGR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_PERSUBENTMGR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PERSUBENTMGR *arg1 = (struct _dwg_object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PERSUBENTMGR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_PERSUBENTMGR" "', argument " "1"" of type '" "struct _dwg_object_PERSUBENTMGR *""'"); 
  }
  arg1 = (struct _dwg_object_PERSUBENTMGR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_PERSUBENTMGR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_PERSUBENTMGR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_PERSUBENTMGR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_0);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_steps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_steps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_subents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_subents);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->steps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->steps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->subents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->subents);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl6 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl6);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl6a = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl6a);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl7a = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl7a);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl7 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl7);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl8);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl9 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl9);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl10 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl10);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl11);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl12 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl12);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl13 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl13);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl14 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl14);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl15 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl15);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl16 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl16);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl17 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl17);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl18 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl18);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl19 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl19);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl20 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl20);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl21 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl21);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl22 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl22);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl23 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl23);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl24 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl24);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl25 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl25);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl26 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl26);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl27 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl27);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl28 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl28);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl29 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl29);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl30 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl30);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl31 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl31);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl32);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl33 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl33);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl34 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl34);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl35 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl35);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl36 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl36);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b37 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b37);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCPERSSUBENTMANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCPERSSUBENTMANAGER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)calloc(1, sizeof(struct _dwg_object_ASSOCPERSSUBENTMANAGER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCPERSSUBENTMANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPERSSUBENTMANAGER *arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCPERSSUBENTMANAGER" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPERSSUBENTMANAGER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCPERSSUBENTMANAGER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCPERSSUBENTMANAGER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCACTIONPARAM *arg1 = (struct _dwg_object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_child_param);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->child_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->child_status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->child_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->child_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->child_param);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->osnap_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_RC) ((arg1)->osnap_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BD) ((arg1)->param);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_child_param);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->child_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->child_status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->child_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->child_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->child_param);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCPOINTREFACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCPOINTREFACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPOINTREFACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCPOINTREFACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPOINTREFACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCPOINTREFACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCPOINTREFACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->asdap_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->asdap_class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCASMBODYACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCASMBODYACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCASMBODYACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCASMBODYACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCASMBODYACTIONPARAM *arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCASMBODYACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCASMBODYACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCASMBODYACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCASMBODYACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_H *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_child_param);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->child_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->child_status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->child_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->child_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->child_param);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->asdap_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->asdap_class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCOBJECTACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCOBJECTACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCOBJECTACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCOBJECTACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOBJECTACTIONPARAM *arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCOBJECTACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOBJECTACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCOBJECTACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCOBJECTACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->asdap_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->asdap_class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_param_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->param);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_action = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_action);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->action_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->action_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->subent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_subent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->subent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCEDGEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCEDGEACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCEDGEACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCEDGEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCEDGEACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCEDGEACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCEDGEACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->asdap_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->asdap_class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFACEACTIONPARAM_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_index_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFACEACTIONPARAM_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFACEACTIONPARAM_index_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCFACEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCFACEACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCFACEACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCFACEACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCFACEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFACEACTIONPARAM *arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCFACEACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFACEACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCFACEACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCFACEACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bs1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_num_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_params_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_params_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_H *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_B) ((arg1)->has_child_param);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->child_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->child_status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->child_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->child_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->child_param = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_param_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->child_param);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bl2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h330_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->h330_3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATHACTIONPARAM_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATHACTIONPARAM_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATHACTIONPARAM_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCPATHACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCPATHACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCPATHACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCPATHACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCPATHACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATHACTIONPARAM *arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCPATHACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATHACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCPATHACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCPATHACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_r2013 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_r2013);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->asdap_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->asdap_class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCVERTEXACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCVERTEXACTIONPARAM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)calloc(1, sizeof(struct _dwg_object_ASSOCVERTEXACTIONPARAM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCVERTEXACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCVERTEXACTIONPARAM *arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCVERTEXACTIONPARAM" "', argument " "1"" of type '" "struct _dwg_object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCVERTEXACTIONPARAM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCVERTEXACTIONPARAM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCVERTEXACTIONPARAM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg2 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_parent_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_parent_set" "', argument " "2"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg2 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_parent_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_class_version_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCARRAYITEM_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_class_version_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_itemloc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) (BITCODE_BL *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_itemloc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_itemloc_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_itemloc_set" "', argument " "2"" of type '" "BITCODE_BL [3]""'"); 
  } 
  arg2 = (BITCODE_BL *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(BITCODE_BL *)&arg1->itemloc[ii] = *((BITCODE_BL *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""itemloc""' of type '""BITCODE_BL [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_itemloc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_itemloc_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_BL *)(BITCODE_BL *) ((arg1)->itemloc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_flags_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCARRAYITEM_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_flags_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_is_default_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_is_default_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_is_default_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCARRAYITEM_is_default_transmatrix_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->is_default_transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_is_default_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_is_default_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (int) ((arg1)->is_default_transmatrix);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_x_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_x_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_x_dir_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_x_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->x_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_x_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_x_dir_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->x_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_rel_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_rel_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_rel_transform_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_rel_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->rel_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_rel_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_rel_transform_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_BD *) ((arg1)->rel_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_has_h1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_has_h1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_has_h1_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCARRAYITEM_has_h1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->has_h1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_has_h1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_has_h1_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (int) ((arg1)->has_h1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_h1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_h1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_h1_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_h1_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_h1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_h1_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_H) ((arg1)->h1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_h2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCARRAYITEM_h2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_h2_set" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCARRAYITEM_h2_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->h2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCARRAYITEM_h2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCARRAYITEM_h2_get" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  result = (BITCODE_H) ((arg1)->h2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ASSOCARRAYITEM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ASSOCARRAYITEM", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ASSOCARRAYITEM *)calloc(1, sizeof(struct _dwg_ASSOCARRAYITEM));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCARRAYITEM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ASSOCARRAYITEM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCARRAYITEM *arg1 = (struct _dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCARRAYITEM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ASSOCARRAYITEM" "', argument " "1"" of type '" "struct _dwg_ASSOCARRAYITEM *""'"); 
  }
  arg1 = (struct _dwg_ASSOCARRAYITEM *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ASSOCARRAYITEM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ASSOCARRAYITEM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ASSOCARRAYITEM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_parent_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_parent_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aap_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_BL) ((arg1)->aap_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_num_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_items);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_classname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_classname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_classname_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_classname_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->classname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->classname = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->classname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_classname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_classname_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_TV) ((arg1)->classname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  Dwg_ASSOCARRAYITEM *arg2 = (Dwg_ASSOCARRAYITEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_items_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCARRAYITEM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_items_set" "', argument " "2"" of type '" "Dwg_ASSOCARRAYITEM *""'"); 
  }
  arg2 = (Dwg_ASSOCARRAYITEM *)(argp2);
  if (arg1) (arg1)->items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCARRAYITEM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_items_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (Dwg_ASSOCARRAYITEM *) ((arg1)->items);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCARRAYITEM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numitems = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numitems_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_BL) ((arg1)->numitems);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numrows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_BL) ((arg1)->numrows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numlevels = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_get" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  result = (BITCODE_BL) ((arg1)->numlevels);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCARRAYPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCARRAYPARAMETERS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)calloc(1, sizeof(struct _dwg_abstractobject_ASSOCARRAYPARAMETERS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCARRAYPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCARRAYPARAMETERS" "', argument " "1"" of type '" "struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *""'"); 
  }
  arg1 = (struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYPARAMETERS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYPARAMETERS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_version_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_version_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_semi_assoc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_semi_assoc);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_l2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_l2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_l2_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_l2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->l2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_l2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_l2_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->l2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_semi_ovr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->is_semi_ovr);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_grip_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_grip_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_grip_status_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_grip_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->grip_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_grip_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_grip_status_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->grip_status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_assocdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCSURFACEACTIONBODY_assocdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_assocdep_set" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_assocdep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assocdep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCSURFACEACTIONBODY_assocdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCSURFACEACTIONBODY_assocdep_get" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assocdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ASSOCSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ASSOCSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ASSOCSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_ASSOCSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ASSOCSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCSURFACEACTIONBODY *arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ASSOCSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_ASSOCSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ASSOCSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ASSOCSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_RC) ((arg1)->option);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCPLANESURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCPLANESURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCPLANESURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCPLANESURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCPLANESURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCEDGEFILLETACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCEDGEFILLETACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCEDGEFILLETACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCEDGEFILLETACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCEDGEFILLETACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BD) ((arg1)->distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b3);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b4);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_B) ((arg1)->b5);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->blend_options = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->blend_options);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->bs2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->bs2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pt1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->pt1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pt2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->pt2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  Dwg_ASSOCSURFACEACTIONBODY *arg2 = (Dwg_ASSOCSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set" "', argument " "2"" of type '" "Dwg_ASSOCSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->sab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (Dwg_ASSOCSURFACEACTIONBODY *)& ((arg1)->sab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->pbsab_status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->pbsab_status);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg2 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTIONBODY_action_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_parent_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCACTIONBODY_action_parent_set" "', argument " "2"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg2 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_parent_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  result = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_depid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTIONBODY_action_depid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_depid_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ASSOCACTIONBODY_action_depid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->depid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_depid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_depid_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  result = (BITCODE_BL) ((arg1)->depid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ASSOCACTIONBODY_action_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_dep_set" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ASSOCACTIONBODY_action_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ASSOCACTIONBODY_action_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ASSOCACTIONBODY_action_dep_get" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  result = (BITCODE_H) ((arg1)->dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ASSOCACTIONBODY_action(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ASSOCACTIONBODY_action", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ASSOCACTIONBODY_action *)calloc(1, sizeof(struct _dwg_ASSOCACTIONBODY_action));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ASSOCACTIONBODY_action(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ASSOCACTIONBODY_action *arg1 = (struct _dwg_ASSOCACTIONBODY_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ASSOCACTIONBODY_action" "', argument " "1"" of type '" "struct _dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg1 = (struct _dwg_ASSOCACTIONBODY_action *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ASSOCACTIONBODY_action_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ASSOCACTIONBODY_action_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assoc_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assoc_dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  Dwg_ASSOCACTIONBODY_action *arg2 = (Dwg_ASSOCACTIONBODY_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set" "', argument " "2"" of type '" "Dwg_ASSOCACTIONBODY_action *""'"); 
  }
  arg2 = (Dwg_ASSOCACTIONBODY_action *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCACTIONBODY_action *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  result = (Dwg_ASSOCACTIONBODY_action *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCACTIONBODY_action, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCMLEADERACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCMLEADERACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCMLEADERACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCMLEADERACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCMLEADERACTIONBODY *arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCMLEADERACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCMLEADERACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCMLEADERACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCMLEADERACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assoc_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assoc_dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->r_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->r_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->d_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->d_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assoc_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assoc_dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->r_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->r_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->d_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->d_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assocdep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assocdep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assoc_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assoc_dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->r_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->r_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->d_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->d_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCORDINATEDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCORDINATEDIMACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCORDINATEDIMACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCORDINATEDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCORDINATEDIMACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assoc_dep = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->assoc_dep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->actionbody = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->actionbody);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->r_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->r_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->d_node = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  result = (BITCODE_H) ((arg1)->d_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCROTATEDDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCROTATEDDIMACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCROTATEDDIMACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCROTATEDDIMACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCROTATEDDIMACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->adb_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->adb_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->dimbase_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->dimbase_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCDIMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCDIMDEPENDENCYBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCDIMDEPENDENCYBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCDIMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCDIMDEPENDENCYBODY *arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCDIMDEPENDENCYBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCDIMDEPENDENCYBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCDIMDEPENDENCYBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCDIMDEPENDENCYBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->adb_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->adb_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->dimbase_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->dimbase_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPARAMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPARAMDEPENDENCYBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)calloc(1, sizeof(struct _dwg_object_BLOCKPARAMDEPENDENCYBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPARAMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPARAMDEPENDENCYBODY" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ARRAYITEMLOCATOR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *arg1 = (struct _dwg_ARRAYITEMLOCATOR *) 0 ;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg2 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ARRAYITEMLOCATOR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ARRAYITEMLOCATOR_parent_set" "', argument " "1"" of type '" "struct _dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg1 = (struct _dwg_ARRAYITEMLOCATOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ARRAYITEMLOCATOR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg2 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ARRAYITEMLOCATOR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *arg1 = (struct _dwg_ARRAYITEMLOCATOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ARRAYITEMLOCATOR_parent_get" "', argument " "1"" of type '" "struct _dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg1 = (struct _dwg_ARRAYITEMLOCATOR *)(argp1);
  result = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ARRAYITEMLOCATOR_itemloc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *arg1 = (struct _dwg_ARRAYITEMLOCATOR *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) (BITCODE_BL *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ARRAYITEMLOCATOR_itemloc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ARRAYITEMLOCATOR_itemloc_set" "', argument " "1"" of type '" "struct _dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg1 = (struct _dwg_ARRAYITEMLOCATOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ARRAYITEMLOCATOR_itemloc_set" "', argument " "2"" of type '" "BITCODE_BL [3]""'"); 
  } 
  arg2 = (BITCODE_BL *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(BITCODE_BL *)&arg1->itemloc[ii] = *((BITCODE_BL *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""itemloc""' of type '""BITCODE_BL [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ARRAYITEMLOCATOR_itemloc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *arg1 = (struct _dwg_ARRAYITEMLOCATOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ARRAYITEMLOCATOR_itemloc_get" "', argument " "1"" of type '" "struct _dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg1 = (struct _dwg_ARRAYITEMLOCATOR *)(argp1);
  result = (BITCODE_BL *)(BITCODE_BL *) ((arg1)->itemloc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ARRAYITEMLOCATOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ARRAYITEMLOCATOR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ARRAYITEMLOCATOR *)calloc(1, sizeof(struct _dwg_ARRAYITEMLOCATOR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ARRAYITEMLOCATOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ARRAYITEMLOCATOR *arg1 = (struct _dwg_ARRAYITEMLOCATOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ARRAYITEMLOCATOR" "', argument " "1"" of type '" "struct _dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg1 = (struct _dwg_ARRAYITEMLOCATOR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ARRAYITEMLOCATOR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ARRAYITEMLOCATOR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->paramblock);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->paramblock = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->paramblock = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->paramblock);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCARRAYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCARRAYACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCARRAYACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCARRAYACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCARRAYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCARRAYACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set" "', argument " "2"" of type '" "Dwg_ASSOCPARAMBASEDACTIONBODY *""'"); 
  }
  arg2 = (Dwg_ASSOCPARAMBASEDACTIONBODY *)(argp2);
  if (arg1) (arg1)->pab = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ASSOCPARAMBASEDACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (Dwg_ASSOCPARAMBASEDACTIONBODY *)& ((arg1)->pab);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ASSOCPARAMBASEDACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->aaab_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->aaab_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->paramblock);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->paramblock = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->paramblock = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_TV) ((arg1)->paramblock);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_BS) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_items);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  Dwg_ARRAYITEMLOCATOR *arg2 = (Dwg_ARRAYITEMLOCATOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set" "', argument " "2"" of type '" "Dwg_ARRAYITEMLOCATOR *""'"); 
  }
  arg2 = (Dwg_ARRAYITEMLOCATOR *)(argp2);
  if (arg1) (arg1)->items = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ARRAYITEMLOCATOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_get" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  result = (Dwg_ARRAYITEMLOCATOR *) ((arg1)->items);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ARRAYITEMLOCATOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)calloc(1, sizeof(struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY" "', argument " "1"" of type '" "struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg1 = (struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_parentid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalExpr_parentid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_parentid_set" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalExpr_parentid_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->parentid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_parentid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_parentid_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (BITCODE_BLd) ((arg1)->parentid);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalExpr_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_major_set" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalExpr_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_major_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalExpr_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_minor_set" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalExpr_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_minor_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_value_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  BITCODE_BSd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalExpr_value_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_value_code_set" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalExpr_value_code_set" "', argument " "2"" of type '" "BITCODE_BSd""'");
  } 
  arg2 = (BITCODE_BSd)(val2);
  if (arg1) (arg1)->value_code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_value_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_value_code_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (BITCODE_BSd) ((arg1)->value_code);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_EvalExpr_value *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_value_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (_dwg_EvalExpr_value *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_nodeid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_EvalExpr_nodeid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_nodeid_set" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_EvalExpr_nodeid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->nodeid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_EvalExpr_nodeid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_EvalExpr_nodeid_get" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  result = (BITCODE_BL) ((arg1)->nodeid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_EvalExpr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_EvalExpr", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_EvalExpr *)calloc(1, sizeof(struct _dwg_EvalExpr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_EvalExpr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_EvalExpr *arg1 = (struct _dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_EvalExpr" "', argument " "1"" of type '" "struct _dwg_EvalExpr *""'"); 
  }
  arg1 = (struct _dwg_EvalExpr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_EvalExpr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EvalExpr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_EvalExpr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_num40_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_num40_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_num40_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalExpr_value_num40_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->num40 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_num40_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_num40_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_BD) ((arg1)->num40);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_pt2d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_pt2d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_pt2d_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalExpr_value_pt2d_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pt2d = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_pt2d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_pt2d_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->pt2d);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_pt3d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_pt3d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_pt3d_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalExpr_value_pt3d_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt3d = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_pt3d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_pt3d_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt3d);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_text1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_text1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_text1_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalExpr_value_text1_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text1);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text1 = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text1 = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_text1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_text1_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_TV) ((arg1)->text1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_long90_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_long90_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_long90_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalExpr_value_long90_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->long90 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_long90_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_long90_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_BL) ((arg1)->long90);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_handle91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_handle91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_handle91_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_EvalExpr_value_handle91_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_handle91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_handle91_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_H) ((arg1)->handle91);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_short70_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_EvalExpr_value_short70_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_short70_set" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_dwg_EvalExpr_value_short70_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->short70 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_EvalExpr_value_short70_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_EvalExpr_value_short70_get" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  result = (BITCODE_BS) ((arg1)->short70);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_EvalExpr_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_EvalExpr_value", 0, 0, 0)) SWIG_fail;
  result = (_dwg_EvalExpr_value *)calloc(1, sizeof(_dwg_EvalExpr_value));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr_value, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_EvalExpr_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_EvalExpr_value *arg1 = (_dwg_EvalExpr_value *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_EvalExpr_value, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_EvalExpr_value" "', argument " "1"" of type '" "_dwg_EvalExpr_value *""'"); 
  }
  arg1 = (_dwg_EvalExpr_value *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_EvalExpr_value_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_EvalExpr_value, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_EvalExpr_value_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentMaterial_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_major_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentMaterial_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_major_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentMaterial_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_minor_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentMaterial_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_minor_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_reflectance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentMaterial_reflectance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_reflectance_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentMaterial_reflectance_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->reflectance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_reflectance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_reflectance_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  result = (BITCODE_BL) ((arg1)->reflectance);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_displacement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentMaterial_displacement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_displacement_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentMaterial_displacement_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->displacement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentMaterial_displacement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentMaterial_displacement_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  result = (BITCODE_BL) ((arg1)->displacement);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ACSH_SubentMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ACSH_SubentMaterial", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ACSH_SubentMaterial *)calloc(1, sizeof(struct _dwg_ACSH_SubentMaterial));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_SubentMaterial, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ACSH_SubentMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentMaterial *arg1 = (struct _dwg_ACSH_SubentMaterial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentMaterial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ACSH_SubentMaterial" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentMaterial *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentMaterial *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ACSH_SubentMaterial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ACSH_SubentMaterial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ACSH_SubentMaterial_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentColor_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_major_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentColor_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_major_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentColor_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_minor_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentColor_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_minor_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentColor_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_transparency_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentColor_transparency_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_transparency_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  result = (BITCODE_BL) ((arg1)->transparency);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_bl93_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentColor_bl93_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_bl93_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentColor_bl93_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl93 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_bl93_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_bl93_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl93);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_is_face_variable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_SubentColor_is_face_variable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_is_face_variable_set" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_SubentColor_is_face_variable_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_face_variable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_SubentColor_is_face_variable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_SubentColor_is_face_variable_get" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  result = (BITCODE_B) ((arg1)->is_face_variable);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ACSH_SubentColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ACSH_SubentColor", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ACSH_SubentColor *)calloc(1, sizeof(struct _dwg_ACSH_SubentColor));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_SubentColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ACSH_SubentColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_SubentColor *arg1 = (struct _dwg_ACSH_SubentColor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_SubentColor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ACSH_SubentColor" "', argument " "1"" of type '" "struct _dwg_ACSH_SubentColor *""'"); 
  }
  arg1 = (struct _dwg_ACSH_SubentColor *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ACSH_SubentColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ACSH_SubentColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ACSH_SubentColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_major_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_HistoryNode_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_major_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_minor_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_HistoryNode_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_minor_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_trans_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_trans_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_trans_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACSH_HistoryNode_trans_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->trans = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_trans_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_trans_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_BD *) ((arg1)->trans);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_color_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACSH_HistoryNode_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_color_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_step_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_step_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_step_id_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ACSH_HistoryNode_step_id_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->step_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_step_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_step_id_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_BL) ((arg1)->step_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ACSH_HistoryNode_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_material_set" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ACSH_HistoryNode_material_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->material = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ACSH_HistoryNode_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ACSH_HistoryNode_material_get" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  result = (BITCODE_H) ((arg1)->material);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ACSH_HistoryNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ACSH_HistoryNode", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ACSH_HistoryNode *)calloc(1, sizeof(struct _dwg_ACSH_HistoryNode));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ACSH_HistoryNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ACSH_HistoryNode *arg1 = (struct _dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ACSH_HistoryNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ACSH_HistoryNode" "', argument " "1"" of type '" "struct _dwg_ACSH_HistoryNode *""'"); 
  }
  arg1 = (struct _dwg_ACSH_HistoryNode *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ACSH_HistoryNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ACSH_HistoryNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ACSH_HistoryNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_owner_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_owner_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_owner_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_owner_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->owner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_owner_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_owner_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_H) ((arg1)->owner);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->h_nodeid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->h_nodeid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_show_history_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_show_history_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_show_history_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_show_history_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_history = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_show_history_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_show_history_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->show_history);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_record_history_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_HISTORY_CLASS_record_history_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_record_history_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_record_history_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->record_history = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_HISTORY_CLASS_record_history_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_HISTORY_CLASS_record_history_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->record_history);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_HISTORY_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_HISTORY_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_HISTORY_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_HISTORY_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_HISTORY_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_HISTORY_CLASS *arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_HISTORY_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_HISTORY_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_HISTORY_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_HISTORY_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_length_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_length_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_width_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_width_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOX_CLASS_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_height_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOX_CLASS_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOX_CLASS_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOX_CLASS_height_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_BOX_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_BOX_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_BOX_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_BOX_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_BOX_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOX_CLASS *arg1 = (struct _dwg_object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_BOX_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOX_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOX_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_BOX_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_BOX_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_length_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_length_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_width_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_width_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_WEDGE_CLASS_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_height_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_WEDGE_CLASS_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_WEDGE_CLASS_height_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_WEDGE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_WEDGE_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_WEDGE_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_WEDGE_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_WEDGE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_WEDGE_CLASS *arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_WEDGE_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_WEDGE_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_WEDGE_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_WEDGE_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->operation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (BITCODE_RCd) ((arg1)->operation);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->operand1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->operand1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->operand2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->operand2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_BOOLEAN_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_BOOLEAN_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_BOOLEAN_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_BOOLEAN_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BOOLEAN_CLASS *arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_BOOLEAN_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BOOLEAN_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_BOOLEAN_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_BOOLEAN_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_acis_empty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_unknown_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_unknown_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_unknown_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_version_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_version_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BS) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_block_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_block_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_block_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_block_size_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->block_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_block_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_block_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL *) ((arg1)->block_size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  if (arg1) (arg1)->encr_sat_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (char **) ((arg1)->encr_sat_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_sab_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_sab_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_sab_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_sab_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sab_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_sab_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_sab_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->sab_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_data_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_data_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_RC *) ((arg1)->acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->wireframe_data_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->wireframe_data_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_point_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_point_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_present_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->point_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_point_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_present_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->point_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_point_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_isolines_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_isolines_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isolines_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isolines_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->isolines = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_isolines_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isolines_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->isolines);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_isoline_present_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_isoline_present_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isoline_present_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isoline_present_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isoline_present = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_isoline_present_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_isoline_present_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->isoline_present);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_num_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_wires_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_wires_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_wires_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_wires);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_wires_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  Dwg_3DSOLID_wire *arg2 = (Dwg_3DSOLID_wire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_wires_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wires_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_wire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wires_set" "', argument " "2"" of type '" "Dwg_3DSOLID_wire *""'"); 
  }
  arg2 = (Dwg_3DSOLID_wire *)(argp2);
  if (arg1) (arg1)->wires = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_wires_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_wire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_wires_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (Dwg_3DSOLID_wire *) ((arg1)->wires);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_wire, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_silhouettes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_silhouettes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  Dwg_3DSOLID_silhouette *arg2 = (Dwg_3DSOLID_silhouette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_silhouettes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_silhouettes_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_silhouette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_silhouettes_set" "', argument " "2"" of type '" "Dwg_3DSOLID_silhouette *""'"); 
  }
  arg2 = (Dwg_3DSOLID_silhouette *)(argp2);
  if (arg1) (arg1)->silhouettes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_silhouettes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_silhouette *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_silhouettes_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (Dwg_3DSOLID_silhouette *) ((arg1)->silhouettes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_silhouette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->_dxf_sab_converted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->_dxf_sab_converted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  struct _dwg_entity_3DSOLID *arg2 = (struct _dwg_entity_3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set" "', argument " "2"" of type '" "struct _dwg_entity_3DSOLID *""'"); 
  }
  arg2 = (struct _dwg_entity_3DSOLID *)(argp2);
  if (arg1) (arg1)->extra_acis_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (struct _dwg_entity_3DSOLID *) ((arg1)->extra_acis_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_num_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_materials_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_materials_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_num_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_num_materials_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_materials);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_materials_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  Dwg_3DSOLID_material *arg2 = (Dwg_3DSOLID_material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_materials_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_materials_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_3DSOLID_material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_materials_set" "', argument " "2"" of type '" "Dwg_3DSOLID_material *""'"); 
  }
  arg2 = (Dwg_3DSOLID_material *)(argp2);
  if (arg1) (arg1)->materials = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_materials_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_3DSOLID_material *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_materials_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (Dwg_3DSOLID_material *) ((arg1)->materials);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_3DSOLID_material, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_guid_set" "', argument " "2"" of type '" "BITCODE_RC [39]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)39; ++ii) *(BITCODE_RC *)&arg1->revision_guid[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_guid""' of type '""BITCODE_RC [39]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_guid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_revision_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->revision_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->revision_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->revision_minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BS) ((arg1)->revision_minor2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->revision_bytes[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""revision_bytes""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_revision_bytes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->revision_bytes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_end_marker_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_end_marker_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_end_marker_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_end_marker_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->end_marker = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_end_marker_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_end_marker_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->end_marker);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_history_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_history_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_id_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_id_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->history_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_history_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_id_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_H) ((arg1)->history_id);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_revision_guid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_revision_guid);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->acis_empty_bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->acis_empty_bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_BREP_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_BREP_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_BREP_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_BREP_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_BREP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_BREP_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_BREP_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_BREP_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_BREP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_BREP_CLASS *arg1 = (struct _dwg_object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_BREP_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_BREP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_BREP_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_BREP_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_BREP_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_direction_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_direction_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_text_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_text_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->shsw_text = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_TF) ((arg1)->shsw_text);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_bl93 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_bl93);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_text2_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_text2_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->shsw_text2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_TF) ((arg1)->shsw_text2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_draft_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_draft_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_draft_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_draft_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->align_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->align_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->sweepentity_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->sweepentity_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->pathentity_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->pathentity_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_align_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_option_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_option_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->align_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_align_option_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_RC) ((arg1)->align_option);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->miter_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_miter_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_RC) ((arg1)->miter_option);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_align_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_align_start);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_bank_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_bank_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bank_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bank_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_bank_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_bank_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->bank);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->check_intersections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->check_intersections);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b294 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b294);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b295 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b295);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b296 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b296);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_pt2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SWEEP_CLASS_pt2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pt2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pt2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SWEEP_CLASS_pt2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SWEEP_CLASS_pt2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_SWEEP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_SWEEP_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_SWEEP_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_SWEEP_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_SWEEP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SWEEP_CLASS *arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_SWEEP_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SWEEP_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_SWEEP_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_SWEEP_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_text_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_text_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->shsw_text = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_TF) ((arg1)->shsw_text);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_bl93 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_bl93);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->shsw_text2_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->shsw_text2_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->shsw_text2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_TF) ((arg1)->shsw_text2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_draft_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_draft_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_draft_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_draft_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->scale_factor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->scale_factor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->align_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->align_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->sweepentity_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->sweepentity_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->pathentity_transform = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->pathentity_transform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->align_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_RC) ((arg1)->align_option);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->miter_option = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_RC) ((arg1)->miter_option);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_align_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_align_start);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bank_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->bank);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->check_intersections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->check_intersections);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b294 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b294);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b295 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b295);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shsw_b296 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->shsw_b296);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_EXTRUSION_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_EXTRUSION_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_EXTRUSION_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_EXTRUSION_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_EXTRUSION_CLASS *arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_EXTRUSION_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_EXTRUSION_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_EXTRUSION_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_EXTRUSION_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_crosssects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_crosssects);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_crosssects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_crosssects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_crosssects_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_crosssects_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->crosssects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_crosssects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_crosssects_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_H *) ((arg1)->crosssects);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_num_guides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_num_guides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_guides_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_guides_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_guides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_num_guides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_num_guides_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_guides);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_guides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_LOFT_CLASS_guides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_guides_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_guides_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->guides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_LOFT_CLASS_guides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_LOFT_CLASS_guides_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  result = (BITCODE_H *) ((arg1)->guides);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_LOFT_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_LOFT_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_LOFT_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_LOFT_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_LOFT_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_LOFT_CLASS *arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_LOFT_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_LOFT_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_LOFT_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_LOFT_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_LOFT_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_num_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_edges_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_edges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_edges_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_edges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_edges_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_edges_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_edges_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL *) ((arg1)->edges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_radiuses = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_radiuses);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_startsetbacks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_startsetbacks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_endsetbacks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_endsetbacks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_radiuses_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_radiuses_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_radiuses_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_radiuses_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->radiuses = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_radiuses_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_radiuses_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->radiuses);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->startsetbacks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->startsetbacks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->endsetbacks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  result = (BITCODE_BD *) ((arg1)->endsetbacks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_FILLET_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_FILLET_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_FILLET_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_FILLET_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_FILLET_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_FILLET_CLASS *arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_FILLET_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_FILLET_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_FILLET_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_FILLET_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_FILLET_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->base_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->base_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->other_dist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->other_dist);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_edges);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_edges_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_edges_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_edges_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL *) ((arg1)->edges);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl95 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl95_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl95);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_CHAMFER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_CHAMFER_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_CHAMFER_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_CHAMFER_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_CHAMFER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CHAMFER_CLASS *arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_CHAMFER_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CHAMFER_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_CHAMFER_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_CHAMFER_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_height_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_height_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->major_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->major_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->minor_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->minor_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->x_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_CYLINDER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_CYLINDER_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_CYLINDER_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_CYLINDER_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_CYLINDER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CYLINDER_CLASS *arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_CYLINDER_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CYLINDER_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_CYLINDER_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_CYLINDER_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_height_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_height_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_major_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_major_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->major_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_major_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_major_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->major_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_minor_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_minor_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->minor_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_minor_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_minor_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->minor_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_x_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_CONE_CLASS_x_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_x_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_CONE_CLASS_x_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_CONE_CLASS_x_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_CONE_CLASS_x_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->x_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_CONE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_CONE_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_CONE_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_CONE_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_CONE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_CONE_CLASS *arg1 = (struct _dwg_object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_CONE_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_CONE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_CONE_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_CONE_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_CONE_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_height_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_height_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_sides_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_sides_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_sides_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_sides_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sides = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_sides_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_sides_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->sides);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->topradius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_PYRAMID_CLASS_topradius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->topradius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_PYRAMID_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_PYRAMID_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_PYRAMID_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_PYRAMID_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_PYRAMID_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_PYRAMID_CLASS *arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_PYRAMID_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_PYRAMID_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_PYRAMID_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_PYRAMID_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_SPHERE_CLASS_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_SPHERE_CLASS_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_SPHERE_CLASS_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_SPHERE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_SPHERE_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_SPHERE_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_SPHERE_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_SPHERE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_SPHERE_CLASS *arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_SPHERE_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_SPHERE_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_SPHERE_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_SPHERE_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_major_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_major_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->major_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_major_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_major_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->major_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->minor_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->minor_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_TORUS_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_TORUS_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_TORUS_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_TORUS_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_TORUS_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_TORUS_CLASS *arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_TORUS_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_TORUS_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_TORUS_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_TORUS_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_TORUS_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  Dwg_ACSH_HistoryNode *arg2 = (Dwg_ACSH_HistoryNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set" "', argument " "2"" of type '" "Dwg_ACSH_HistoryNode *""'"); 
  }
  arg2 = (Dwg_ACSH_HistoryNode *)(argp2);
  if (arg1) (arg1)->history_node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_history_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ACSH_HistoryNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (Dwg_ACSH_HistoryNode *)& ((arg1)->history_node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ACSH_HistoryNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_major_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_major_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_minor_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_minor_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BL) ((arg1)->minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->axis_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->axis_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_direction_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_direction_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_direction_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->revolve_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->revolve_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->draft_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->draft_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd44 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd44_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd44);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd45 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd45_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd45);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->twist_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_BD) ((arg1)->twist_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_b290_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_b290_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_b290_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_b290_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b290 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_b290_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_b290_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->b290);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_close_to_axis = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_B) ((arg1)->is_close_to_axis);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sweep_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_get" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  result = (BITCODE_H) ((arg1)->sweep_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACSH_REVOLVE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACSH_REVOLVE_CLASS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACSH_REVOLVE_CLASS *)calloc(1, sizeof(struct _dwg_object_ACSH_REVOLVE_CLASS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACSH_REVOLVE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACSH_REVOLVE_CLASS *arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACSH_REVOLVE_CLASS" "', argument " "1"" of type '" "struct _dwg_object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg1 = (struct _dwg_object_ACSH_REVOLVE_CLASS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACSH_REVOLVE_CLASS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACSH_REVOLVE_CLASS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NAVISWORKSMODEL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NAVISWORKSMODEL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NAVISWORKSMODEL_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NAVISWORKSMODEL_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_definition_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NAVISWORKSMODEL_definition_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_definition_set" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NAVISWORKSMODEL_definition_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->definition = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_definition_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_definition_get" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  result = (BITCODE_H) ((arg1)->definition);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_transmatrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NAVISWORKSMODEL_transmatrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_transmatrix_set" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_NAVISWORKSMODEL_transmatrix_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->transmatrix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_transmatrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_transmatrix_get" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  result = (BITCODE_BD *) ((arg1)->transmatrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_unitfactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_NAVISWORKSMODEL_unitfactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_unitfactor_set" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_NAVISWORKSMODEL_unitfactor_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->unitfactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_NAVISWORKSMODEL_unitfactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_NAVISWORKSMODEL_unitfactor_get" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  result = (BITCODE_BD) ((arg1)->unitfactor);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_NAVISWORKSMODEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_NAVISWORKSMODEL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_NAVISWORKSMODEL *)calloc(1, sizeof(struct _dwg_entity_NAVISWORKSMODEL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_NAVISWORKSMODEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_NAVISWORKSMODEL *arg1 = (struct _dwg_entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_NAVISWORKSMODEL" "', argument " "1"" of type '" "struct _dwg_entity_NAVISWORKSMODEL *""'"); 
  }
  arg1 = (struct _dwg_entity_NAVISWORKSMODEL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_NAVISWORKSMODEL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_NAVISWORKSMODEL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_parent_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_parent_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_flags_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_flags_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_path_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_path_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->path);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->path = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->path = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_path_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->path);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_status_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_status_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_status_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_status_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->status = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_status_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_status_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->status);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_min_extent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_min_extent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_min_extent_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_min_extent_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->min_extent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_min_extent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_min_extent_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->min_extent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_max_extent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_max_extent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_max_extent_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_max_extent_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->max_extent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_max_extent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_max_extent_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->max_extent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->host_drawing_visibility = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_get" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->host_drawing_visibility);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_NAVISWORKSMODELDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_NAVISWORKSMODELDEF", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_NAVISWORKSMODELDEF *)calloc(1, sizeof(struct _dwg_object_NAVISWORKSMODELDEF));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_NAVISWORKSMODELDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_NAVISWORKSMODELDEF *arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_NAVISWORKSMODELDEF" "', argument " "1"" of type '" "struct _dwg_object_NAVISWORKSMODELDEF *""'"); 
  }
  arg1 = (struct _dwg_object_NAVISWORKSMODELDEF *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_NAVISWORKSMODELDEF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_NAVISWORKSMODELDEF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERSETTINGS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_name_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERSETTINGS_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_name_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_fog_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_fog_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_fog_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_fog_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_fog_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_fog_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_fog_background_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_fog_background_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_fog_background_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_fog_background_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_background_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_fog_background_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_fog_background_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_background_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_backfaces_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_backfaces_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_backfaces_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_backfaces_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->backfaces_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_backfaces_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_backfaces_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->backfaces_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_environ_image_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_environ_image_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->environ_image_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_environ_image_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->environ_image_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_environ_image_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_environ_image_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_filename_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->environ_image_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->environ_image_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->environ_image_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_environ_image_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_environ_image_filename_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->environ_image_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_description_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERSETTINGS_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_description_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_display_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_display_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_display_index_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_display_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_display_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_display_index_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_has_predefined_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERSETTINGS_has_predefined_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_has_predefined_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERSETTINGS_has_predefined_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_predefined = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERSETTINGS_has_predefined_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERSETTINGS_has_predefined_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_predefined);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RENDERSETTINGS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RENDERSETTINGS *)calloc(1, sizeof(struct _dwg_object_RENDERSETTINGS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERSETTINGS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERSETTINGS *arg1 = (struct _dwg_object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RENDERSETTINGS" "', argument " "1"" of type '" "struct _dwg_object_RENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERSETTINGS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RENDERSETTINGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RENDERSETTINGS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RENDERSETTINGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_name_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_name_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_background_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_background_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->backfaces_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->backfaces_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->environ_image_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->environ_image_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->environ_image_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->environ_image_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->environ_image_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->environ_image_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_description_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_description_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_predefined = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_predefined);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->mr_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->mr_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sampling1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->sampling1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->sampling2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->sampling2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->sampling_mr_filter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->sampling_mr_filter);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_filter1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_filter1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_filter2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_filter2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_contrast_color1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_contrast_color1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_contrast_color2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_contrast_color2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_contrast_color3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_contrast_color3);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->sampling_contrast_color4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->sampling_contrast_color4);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->shadow_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->shadow_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->shadow_maps_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->shadow_maps_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->ray_tracing_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->ray_tracing_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->ray_trace_depth1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->ray_trace_depth1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->ray_trace_depth2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->ray_trace_depth2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->ray_trace_depth3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->ray_trace_depth3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->global_illumination_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->global_illumination_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->gi_sample_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->gi_sample_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->gi_sample_radius_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->gi_sample_radius_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gi_sample_radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->gi_sample_radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->gi_photons_per_light = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->gi_photons_per_light);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->photon_trace_depth1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->photon_trace_depth1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->photon_trace_depth2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->photon_trace_depth2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->photon_trace_depth3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->photon_trace_depth3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->final_gathering_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->final_gathering_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->fg_ray_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->fg_ray_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fg_sample_radius_state1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fg_sample_radius_state1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fg_sample_radius_state2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fg_sample_radius_state2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fg_sample_radius_state3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fg_sample_radius_state3);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fg_sample_radius1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->fg_sample_radius1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fg_sample_radius2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->fg_sample_radius2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->light_luminance_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->light_luminance_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->diagnostics_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->diagnostics_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->diagnostics_grid_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->diagnostics_grid_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->diagnostics_grid_float = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->diagnostics_grid_float);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->diagnostics_photon_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->diagnostics_photon_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->diagnostics_bsp_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->diagnostics_bsp_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->export_mi_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->export_mi_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->mr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->mr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->mr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->mr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->tile_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->tile_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->tile_order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->tile_order);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->memory_limit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->memory_limit);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->diagnostics_samples_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->diagnostics_samples_mode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->energy_multiplier = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_get" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->energy_multiplier);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MENTALRAYRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MENTALRAYRENDERSETTINGS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)calloc(1, sizeof(struct _dwg_object_MENTALRAYRENDERSETTINGS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MENTALRAYRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MENTALRAYRENDERSETTINGS *arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MENTALRAYRENDERSETTINGS" "', argument " "1"" of type '" "struct _dwg_object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_MENTALRAYRENDERSETTINGS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MENTALRAYRENDERSETTINGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MENTALRAYRENDERSETTINGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_name_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_name_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_background_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_background_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->backfaces_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->backfaces_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->environ_image_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->environ_image_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->environ_image_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->environ_image_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->environ_image_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->environ_image_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_description_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_description_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_predefined = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_B) ((arg1)->has_predefined);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->rapidrt_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->rapidrt_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->render_target = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->render_target);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->render_level = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->render_level);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->render_time = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->render_time);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->lighting_model = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->lighting_model);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->filter_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->filter_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->filter_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->filter_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->filter_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_get" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  result = (BITCODE_BD) ((arg1)->filter_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RAPIDRTRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RAPIDRTRENDERSETTINGS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)calloc(1, sizeof(struct _dwg_object_RAPIDRTRENDERSETTINGS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RAPIDRTRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RAPIDRTRENDERSETTINGS *arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RAPIDRTRENDERSETTINGS" "', argument " "1"" of type '" "struct _dwg_object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_RAPIDRTRENDERSETTINGS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RAPIDRTRENDERSETTINGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RAPIDRTRENDERSETTINGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENVIRONMENT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fog_background_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_B) ((arg1)->fog_background_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_r_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_color_r_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_r_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_r_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fog_color_r = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_r_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_r_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_RC) ((arg1)->fog_color_r);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_g_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_color_g_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_g_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_g_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fog_color_g = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_g_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_g_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_RC) ((arg1)->fog_color_g);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_color_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_b_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_b_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->fog_color_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_color_b_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_RC) ((arg1)->fog_color_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_near_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_density_near_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_near_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_near_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fog_density_near = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_near_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_near_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_BD) ((arg1)->fog_density_near);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_far_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_density_far_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_far_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_far_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fog_density_far = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_far_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_density_far_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_BD) ((arg1)->fog_density_far);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fog_distance_near = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_near_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_BD) ((arg1)->fog_distance_near);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->fog_distance_far = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_far_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_BD) ((arg1)->fog_distance_far);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->environ_image_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_B) ((arg1)->environ_image_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->environ_image_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->environ_image_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->environ_image_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  result = (BITCODE_TV) ((arg1)->environ_image_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RENDERENVIRONMENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RENDERENVIRONMENT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RENDERENVIRONMENT *)calloc(1, sizeof(struct _dwg_object_RENDERENVIRONMENT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RENDERENVIRONMENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENVIRONMENT *arg1 = (struct _dwg_object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RENDERENVIRONMENT" "', argument " "1"" of type '" "struct _dwg_object_RENDERENVIRONMENT *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENVIRONMENT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RENDERENVIRONMENT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RENDERENVIRONMENT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERGLOBAL_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_procedure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_procedure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_procedure_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_procedure_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->procedure = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_procedure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_procedure_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->procedure);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_destination_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_destination_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_destination_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_destination_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->destination = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_destination_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_destination_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->destination);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_save_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_save_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_save_enabled_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_save_enabled_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->save_enabled = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_save_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_save_enabled_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_B) ((arg1)->save_enabled);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_save_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_save_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_save_filename_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERGLOBAL_save_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->save_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->save_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->save_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_save_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_save_filename_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_TV) ((arg1)->save_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_image_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_image_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_image_width_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_image_width_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->image_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_image_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_image_width_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->image_width);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_image_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_image_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_image_height_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_image_height_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->image_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_image_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_image_height_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_BL) ((arg1)->image_height);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_predef_presets_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_predef_presets_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_predef_presets_first_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_predef_presets_first_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->predef_presets_first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_predef_presets_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_predef_presets_first_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_B) ((arg1)->predef_presets_first);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_highlevel_info_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERGLOBAL_highlevel_info_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_highlevel_info_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERGLOBAL_highlevel_info_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->highlevel_info = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERGLOBAL_highlevel_info_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERGLOBAL_highlevel_info_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  result = (BITCODE_B) ((arg1)->highlevel_info);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RENDERGLOBAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RENDERGLOBAL", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RENDERGLOBAL *)calloc(1, sizeof(struct _dwg_object_RENDERGLOBAL));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERGLOBAL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RENDERGLOBAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERGLOBAL *arg1 = (struct _dwg_object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERGLOBAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RENDERGLOBAL" "', argument " "1"" of type '" "struct _dwg_object_RENDERGLOBAL *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERGLOBAL *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RENDERGLOBAL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RENDERGLOBAL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RENDERGLOBAL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENTRY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_image_file_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_image_file_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_image_file_name_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENTRY_image_file_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->image_file_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->image_file_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->image_file_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_image_file_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_image_file_name_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_TV) ((arg1)->image_file_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_preset_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_preset_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_preset_name_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENTRY_preset_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->preset_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->preset_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->preset_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_preset_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_preset_name_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_TV) ((arg1)->preset_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_view_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_view_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_view_name_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RENDERENTRY_view_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->view_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->view_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->view_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_view_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_view_name_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_TV) ((arg1)->view_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_dimension_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_dimension_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_dimension_x_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_dimension_x_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dimension_x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_dimension_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_dimension_x_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->dimension_x);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_dimension_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_dimension_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_dimension_y_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_dimension_y_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dimension_y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_dimension_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_dimension_y_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->dimension_y);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_year_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_year_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_year_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_year_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_year = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_year_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_year_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_year);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_month_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_month_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_month_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_month_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_month = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_month_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_month_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_month);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_day_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_day_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_day_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_day_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_day = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_day_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_day_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_day);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_minute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_minute_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_minute_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_minute_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_minute = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_minute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_minute_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_minute);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_second_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_second_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_second_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_second);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_msec_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_start_msec_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_msec_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_start_msec_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->start_msec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_start_msec_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_start_msec_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BS) ((arg1)->start_msec);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_render_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_render_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_render_time_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_render_time_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->render_time = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_render_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_render_time_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BD) ((arg1)->render_time);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_memory_amount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_memory_amount_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_memory_amount_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_memory_amount_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->memory_amount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_memory_amount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_memory_amount_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->memory_amount);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_material_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_material_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_material_count_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_material_count_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->material_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_material_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_material_count_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->material_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_light_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_light_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_light_count_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_light_count_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->light_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_light_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_light_count_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->light_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_triangle_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_triangle_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_triangle_count_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_triangle_count_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->triangle_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_triangle_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_triangle_count_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->triangle_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_display_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RENDERENTRY_display_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_display_index_set" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RENDERENTRY_display_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->display_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RENDERENTRY_display_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RENDERENTRY_display_index_get" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  result = (BITCODE_BL) ((arg1)->display_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RENDERENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RENDERENTRY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RENDERENTRY *)calloc(1, sizeof(struct _dwg_object_RENDERENTRY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENTRY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RENDERENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RENDERENTRY *arg1 = (struct _dwg_object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RENDERENTRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RENDERENTRY" "', argument " "1"" of type '" "struct _dwg_object_RENDERENTRY *""'"); 
  }
  arg1 = (struct _dwg_object_RENDERENTRY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RENDERENTRY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RENDERENTRY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RENDERENTRY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MOTIONPATH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MOTIONPATH_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_camera_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_camera_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_camera_path_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MOTIONPATH_camera_path_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->camera_path = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_camera_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_camera_path_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_H) ((arg1)->camera_path);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_target_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_target_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_target_path_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MOTIONPATH_target_path_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->target_path = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_target_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_target_path_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_H) ((arg1)->target_path);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_viewtable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_viewtable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_viewtable_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MOTIONPATH_viewtable_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->viewtable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_viewtable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_viewtable_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_H) ((arg1)->viewtable);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_frames_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_frames_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_frames_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MOTIONPATH_frames_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->frames = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_frames_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_frames_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_BS) ((arg1)->frames);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_frame_rate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_frame_rate_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_frame_rate_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MOTIONPATH_frame_rate_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->frame_rate = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_frame_rate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_frame_rate_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_BS) ((arg1)->frame_rate);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_corner_decel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MOTIONPATH_corner_decel_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_corner_decel_set" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MOTIONPATH_corner_decel_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->corner_decel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MOTIONPATH_corner_decel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MOTIONPATH_corner_decel_get" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  result = (BITCODE_B) ((arg1)->corner_decel);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MOTIONPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MOTIONPATH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MOTIONPATH *)calloc(1, sizeof(struct _dwg_object_MOTIONPATH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MOTIONPATH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MOTIONPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MOTIONPATH *arg1 = (struct _dwg_object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MOTIONPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MOTIONPATH" "', argument " "1"" of type '" "struct _dwg_object_MOTIONPATH *""'"); 
  }
  arg1 = (struct _dwg_object_MOTIONPATH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MOTIONPATH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MOTIONPATH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MOTIONPATH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CURVEPATH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_parent_set" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CURVEPATH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_parent_get" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CURVEPATH_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_CURVEPATH_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CURVEPATH_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_entity_set" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CURVEPATH_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CURVEPATH_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CURVEPATH_entity_get" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  result = (BITCODE_H) ((arg1)->entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_CURVEPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_CURVEPATH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_CURVEPATH *)calloc(1, sizeof(struct _dwg_object_CURVEPATH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CURVEPATH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_CURVEPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CURVEPATH *arg1 = (struct _dwg_object_CURVEPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CURVEPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_CURVEPATH" "', argument " "1"" of type '" "struct _dwg_object_CURVEPATH *""'"); 
  }
  arg1 = (struct _dwg_object_CURVEPATH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_CURVEPATH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_CURVEPATH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_CURVEPATH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTPATH_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTPATH_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTPATH_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTPATH_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTPATH_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_point_set" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTPATH_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTPATH_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTPATH_point_get" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTPATH", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTPATH *)calloc(1, sizeof(struct _dwg_object_POINTPATH));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTPATH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTPATH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTPATH *arg1 = (struct _dwg_object_POINTPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTPATH" "', argument " "1"" of type '" "struct _dwg_object_POINTPATH *""'"); 
  }
  arg1 = (struct _dwg_object_POINTPATH *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTPATH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTPATH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTPATH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_parent_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_parent_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_flags_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_flags_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->max_regen_threads = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BS) ((arg1)->max_regen_threads);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->use_lut_palette = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BL) ((arg1)->use_lut_palette);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->alt_hlt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BLL) ((arg1)->alt_hlt);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->alt_hltcolor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BLL) ((arg1)->alt_hltcolor);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->geom_shader_usage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BLL) ((arg1)->geom_shader_usage);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->blending_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_blending_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BL) ((arg1)->blending_mode);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->antialiasing_level = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BD) ((arg1)->antialiasing_level);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_bd2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TVDEVICEPROPERTIES_bd2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_bd2_set" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_bd2_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bd2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TVDEVICEPROPERTIES_bd2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TVDEVICEPROPERTIES_bd2_get" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  result = (BITCODE_BD) ((arg1)->bd2);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_TVDEVICEPROPERTIES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_TVDEVICEPROPERTIES", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_TVDEVICEPROPERTIES *)calloc(1, sizeof(struct _dwg_object_TVDEVICEPROPERTIES));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_TVDEVICEPROPERTIES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TVDEVICEPROPERTIES *arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_TVDEVICEPROPERTIES" "', argument " "1"" of type '" "struct _dwg_object_TVDEVICEPROPERTIES *""'"); 
  }
  arg1 = (struct _dwg_object_TVDEVICEPROPERTIES *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_TVDEVICEPROPERTIES_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_TVDEVICEPROPERTIES_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SKYLIGHT_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->sunid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SKYLIGHT_BACKGROUND_sunid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_get" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  result = (BITCODE_H) ((arg1)->sunid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SKYLIGHT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SKYLIGHT_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SKYLIGHT_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_SKYLIGHT_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SKYLIGHT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SKYLIGHT_BACKGROUND *arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SKYLIGHT_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SKYLIGHT_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SKYLIGHT_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SKYLIGHT_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SOLID_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SOLID_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SOLID_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SOLID_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SOLID_BACKGROUND_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_color_set" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SOLID_BACKGROUND_color_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SOLID_BACKGROUND_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SOLID_BACKGROUND_color_get" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SOLID_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SOLID_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SOLID_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_SOLID_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SOLID_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SOLID_BACKGROUND *arg1 = (struct _dwg_object_SOLID_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SOLID_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_SOLID_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_SOLID_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SOLID_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SOLID_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_filename_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_filename_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_TV) ((arg1)->filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->fit_to_screen = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_B) ((arg1)->fit_to_screen);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->maintain_aspect_ratio = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_B) ((arg1)->maintain_aspect_ratio);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_use_tiling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_use_tiling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_use_tiling_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_use_tiling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->use_tiling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_use_tiling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_use_tiling_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_B) ((arg1)->use_tiling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_2BD *arg2 = (BITCODE_2BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_offset_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_offset_set" "', argument " "2"" of type '" "BITCODE_2BD *""'"); 
  }
  arg2 = (BITCODE_2BD *)(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_offset_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_2BD *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  BITCODE_2BD *arg2 = (BITCODE_2BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IMAGE_BACKGROUND_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_scale_set" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IMAGE_BACKGROUND_scale_set" "', argument " "2"" of type '" "BITCODE_2BD *""'"); 
  }
  arg2 = (BITCODE_2BD *)(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IMAGE_BACKGROUND_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IMAGE_BACKGROUND_scale_get" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  result = (BITCODE_2BD *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_IMAGE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_IMAGE_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_IMAGE_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_IMAGE_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_IMAGE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IMAGE_BACKGROUND *arg1 = (struct _dwg_object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_IMAGE_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_IMAGE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IMAGE_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_IMAGE_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_IMAGE_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IBL_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IBL_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_enable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_enable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_enable_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IBL_BACKGROUND_enable_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->enable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_enable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_enable_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_B) ((arg1)->enable);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_name_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IBL_BACKGROUND_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_name_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IBL_BACKGROUND_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_display_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_display_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_display_image_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_IBL_BACKGROUND_display_image_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->display_image = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_display_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_display_image_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_B) ((arg1)->display_image);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_secondary_background_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_IBL_BACKGROUND_secondary_background_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_secondary_background_set" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_IBL_BACKGROUND_secondary_background_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->secondary_background = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_IBL_BACKGROUND_secondary_background_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_IBL_BACKGROUND_secondary_background_get" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  result = (BITCODE_H) ((arg1)->secondary_background);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_IBL_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_IBL_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_IBL_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_IBL_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IBL_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_IBL_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_IBL_BACKGROUND *arg1 = (struct _dwg_object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_IBL_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_IBL_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_IBL_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_IBL_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_IBL_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_IBL_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_color_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_top_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_top_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_top = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_top_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_top);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_middle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_color_middle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_middle_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_middle_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_middle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_middle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_middle_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_middle);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_bottom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_color_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_bottom);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_horizon_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_horizon_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_horizon_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_horizon_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->horizon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_horizon_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_horizon_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BD) ((arg1)->horizon);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_height_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_height_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GRADIENT_BACKGROUND_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GRADIENT_BACKGROUND_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GRADIENT_BACKGROUND_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_GRADIENT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_GRADIENT_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_GRADIENT_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_GRADIENT_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_GRADIENT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GRADIENT_BACKGROUND *arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_GRADIENT_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_GRADIENT_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GRADIENT_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_GRADIENT_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_GRADIENT_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_sky_zenith = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_sky_zenith);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_sky_horizon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_sky_horizon);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_underground_horizon = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_underground_horizon);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_underground_azimuth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_underground_azimuth);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_near = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_near);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  BITCODE_BLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set" "', argument " "2"" of type '" "BITCODE_BLx""'");
  } 
  arg2 = (BITCODE_BLx)(val2);
  if (arg1) (arg1)->color_far = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_get" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  result = (BITCODE_BLx) ((arg1)->color_far);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_GROUND_PLANE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_GROUND_PLANE_BACKGROUND", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)calloc(1, sizeof(struct _dwg_object_GROUND_PLANE_BACKGROUND));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_GROUND_PLANE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_GROUND_PLANE_BACKGROUND *arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_GROUND_PLANE_BACKGROUND" "', argument " "1"" of type '" "struct _dwg_object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg1 = (struct _dwg_object_GROUND_PLANE_BACKGROUND *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_GROUND_PLANE_BACKGROUND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_GROUND_PLANE_BACKGROUND_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  struct _dwg_CONTEXTDATA_submgr *arg2 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_dict_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_parent_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_dict_parent_set" "', argument " "2"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg2 = (struct _dwg_CONTEXTDATA_submgr *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_CONTEXTDATA_submgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_parent_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  result = (struct _dwg_CONTEXTDATA_submgr *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_text_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_dict_text_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_text_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_dict_text_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_text_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_text_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  result = (BITCODE_TV) ((arg1)->text);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_itemhandle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_dict_itemhandle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_itemhandle_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_dict_itemhandle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->itemhandle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_dict_itemhandle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_dict_itemhandle_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  result = (BITCODE_H) ((arg1)->itemhandle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_CONTEXTDATA_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_CONTEXTDATA_dict", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_CONTEXTDATA_dict *)calloc(1, sizeof(struct _dwg_CONTEXTDATA_dict));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONTEXTDATA_dict, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_CONTEXTDATA_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_dict *arg1 = (struct _dwg_CONTEXTDATA_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_dict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_CONTEXTDATA_dict" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_dict *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_dict *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_CONTEXTDATA_dict_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_CONTEXTDATA_dict, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_CONTEXTDATA_dict_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  struct _dwg_object_CONTEXTDATAMANAGER *arg2 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_submgr_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_parent_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_submgr_parent_set" "', argument " "2"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg2 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_CONTEXTDATAMANAGER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_parent_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  result = (struct _dwg_object_CONTEXTDATAMANAGER *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_submgr_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_handle_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_submgr_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_handle_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  result = (BITCODE_H) ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_submgr_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_num_entries_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_CONTEXTDATA_submgr_num_entries_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_num_entries_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  Dwg_CONTEXTDATA_dict *arg2 = (Dwg_CONTEXTDATA_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_CONTEXTDATA_submgr_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_entries_set" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CONTEXTDATA_dict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_CONTEXTDATA_submgr_entries_set" "', argument " "2"" of type '" "Dwg_CONTEXTDATA_dict *""'"); 
  }
  arg2 = (Dwg_CONTEXTDATA_dict *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_CONTEXTDATA_submgr_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CONTEXTDATA_dict *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_CONTEXTDATA_submgr_entries_get" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  result = (Dwg_CONTEXTDATA_dict *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONTEXTDATA_dict, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_CONTEXTDATA_submgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_CONTEXTDATA_submgr", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_CONTEXTDATA_submgr *)calloc(1, sizeof(struct _dwg_CONTEXTDATA_submgr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONTEXTDATA_submgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_CONTEXTDATA_submgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_CONTEXTDATA_submgr *arg1 = (struct _dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_CONTEXTDATA_submgr" "', argument " "1"" of type '" "struct _dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg1 = (struct _dwg_CONTEXTDATA_submgr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_CONTEXTDATA_submgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_CONTEXTDATA_submgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_CONTEXTDATA_submgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CONTEXTDATAMANAGER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->objectcontext = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_objectcontext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_get" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  result = (BITCODE_H) ((arg1)->objectcontext);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_submgrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_get" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_submgrs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_submgrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  Dwg_CONTEXTDATA_submgr *arg2 = (Dwg_CONTEXTDATA_submgr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CONTEXTDATAMANAGER_submgrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_submgrs_set" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_CONTEXTDATA_submgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_submgrs_set" "', argument " "2"" of type '" "Dwg_CONTEXTDATA_submgr *""'"); 
  }
  arg2 = (Dwg_CONTEXTDATA_submgr *)(argp2);
  if (arg1) (arg1)->submgrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CONTEXTDATAMANAGER_submgrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_CONTEXTDATA_submgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CONTEXTDATAMANAGER_submgrs_get" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  result = (Dwg_CONTEXTDATA_submgr *) ((arg1)->submgrs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_CONTEXTDATA_submgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_CONTEXTDATAMANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_CONTEXTDATAMANAGER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_CONTEXTDATAMANAGER *)calloc(1, sizeof(struct _dwg_object_CONTEXTDATAMANAGER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_CONTEXTDATAMANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CONTEXTDATAMANAGER *arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_CONTEXTDATAMANAGER" "', argument " "1"" of type '" "struct _dwg_object_CONTEXTDATAMANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_CONTEXTDATAMANAGER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_CONTEXTDATAMANAGER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_CONTEXTDATAMANAGER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->horizontal_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->horizontal_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_TEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_TEXTOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_TEXTOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_TEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_TEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_TEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_TEXTOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_TEXTOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_TEXTOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->attachment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->x_axis_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->x_axis_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rect_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->rect_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->extents_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->extents_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->column_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->column_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->column_width = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->column_width);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->gutter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->gutter);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->auto_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->auto_height);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flow_reversed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->flow_reversed);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_column_heights);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->column_heights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD *) ((arg1)->column_heights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MTEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MTEXTOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_MTEXTOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MTEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MTEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MTEXTOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MTEXTOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_b293_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_b293_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_b293_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_b293_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b293 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_b293_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_b293_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->b293);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_def_pt_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_OCD_Dimension_def_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_def_pt_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_is_def_textloc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_is_def_textloc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_is_def_textloc_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_is_def_textloc_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_def_textloc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_is_def_textloc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_is_def_textloc_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->is_def_textloc);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_text_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_text_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_text_rotation_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_text_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->text_rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_text_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_text_rotation_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_BD) ((arg1)->text_rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_block_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_OCD_Dimension_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_block_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtofl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_dimtofl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtofl_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_dimtofl_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dimtofl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtofl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtofl_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->dimtofl);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimosxd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_dimosxd_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimosxd_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_dimosxd_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dimosxd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimosxd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimosxd_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->dimosxd);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimatfit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_dimatfit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimatfit_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_dimatfit_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dimatfit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimatfit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimatfit_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->dimatfit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_dimtix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtix_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_dimtix_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dimtix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtix_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->dimtix);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtmove_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_dimtmove_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtmove_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_dimtmove_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dimtmove = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_dimtmove_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_dimtmove_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->dimtmove);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_override_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_override_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_override_code_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_override_code_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->override_code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_override_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_override_code_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_RC) ((arg1)->override_code);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_has_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_has_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_has_arrow2_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_has_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_has_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_has_arrow2_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->has_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_flip_arrow2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_flip_arrow2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_flip_arrow2_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_flip_arrow2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_flip_arrow2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_flip_arrow2_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_flip_arrow1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_OCD_Dimension_flip_arrow1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_flip_arrow1_set" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_OCD_Dimension_flip_arrow1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->flip_arrow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_OCD_Dimension_flip_arrow1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_OCD_Dimension_flip_arrow1_get" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  result = (BITCODE_B) ((arg1)->flip_arrow1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_OCD_Dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_OCD_Dimension", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_OCD_Dimension *)calloc(1, sizeof(struct _dwg_OCD_Dimension));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_OCD_Dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_OCD_Dimension *arg1 = (struct _dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_OCD_Dimension, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_OCD_Dimension" "', argument " "1"" of type '" "struct _dwg_OCD_Dimension *""'"); 
  }
  arg1 = (struct _dwg_OCD_Dimension *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_OCD_Dimension_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_OCD_Dimension, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_OCD_Dimension_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->dimline_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_get" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->dimline_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ALDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ALDIMOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_ALDIMOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ALDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ALDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ALDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ALDIMOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ALDIMOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ALDIMOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->arc_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_get" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->arc_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ANGDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ANGDIMOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_ANGDIMOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ANGDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ANGDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->first_arc_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->first_arc_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DMDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DMDIMOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_DMDIMOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DMDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DMDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DMDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_DMDIMOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DMDIMOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DMDIMOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->feature_location_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->feature_location_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->leader_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->leader_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ORDDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ORDDIMOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_ORDDIMOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ORDDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ORDDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->first_arc_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->first_arc_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RADIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RADIMOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_RADIMOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RADIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RADIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RADIMOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RADIMOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  Dwg_OCD_Dimension *arg2 = (Dwg_OCD_Dimension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set" "', argument " "2"" of type '" "Dwg_OCD_Dimension *""'"); 
  }
  arg2 = (Dwg_OCD_Dimension *)(argp2);
  if (arg1) (arg1)->dimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_OCD_Dimension *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_OCD_Dimension *)& ((arg1)->dimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_OCD_Dimension, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ovr_center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ovr_center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->jog_point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_get" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->jog_point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_RADIMLGOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_RADIMLGOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_RADIMLGOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_RADIMLGOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_RADIMLGOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->horizontal_mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->horizontal_mode);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->alignment_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_2RD *)& ((arg1)->alignment_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->enable_context = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->enable_context);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  Dwg_Object_SCALE *arg2 = (Dwg_Object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set" "', argument " "2"" of type '" "Dwg_Object_SCALE *""'"); 
  }
  arg2 = (Dwg_Object_SCALE *)(argp2);
  if (arg1) (arg1)->context = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SCALE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_get" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  result = (Dwg_Object_SCALE *)& ((arg1)->context);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_MLEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_MLEADEROBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_MLEADEROBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_MLEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_MLEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_MLEADEROBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_MLEADEROBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_MLEADEROBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_MLEADEROBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_points);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->points = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_points_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3DPOINT *) ((arg1)->points);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b290 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->b290);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->x_direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->x_direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->inspt_offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->inspt_offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  BITCODE_3DPOINT *arg2 = (BITCODE_3DPOINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set" "', argument " "2"" of type '" "BITCODE_3DPOINT *""'"); 
  }
  arg2 = (BITCODE_3DPOINT *)(argp2);
  if (arg1) (arg1)->endptproj = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3DPOINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_get" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3DPOINT *)& ((arg1)->endptproj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LEADEROBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_LEADEROBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LEADEROBJECTCONTEXTDATA *arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LEADEROBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_LEADEROBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LEADEROBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LEADEROBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ins_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ins_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->scale_factor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_get" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->scale_factor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLKREFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLKREFOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_BLKREFOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLKREFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLKREFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLKREFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BLKREFOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLKREFOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLKREFOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_default = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_B) ((arg1)->is_default);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_location_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_location_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->horiz_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_get" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->horiz_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_FCFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_FCFOBJECTCONTEXTDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)calloc(1, sizeof(struct _dwg_object_FCFOBJECTCONTEXTDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_FCFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_FCFOBJECTCONTEXTDATA *arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_FCFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "struct _dwg_object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg1 = (struct _dwg_object_FCFOBJECTCONTEXTDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_FCFOBJECTCONTEXTDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_FCFOBJECTCONTEXTDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->mdoc_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->mdoc_class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_desc_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_desc_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_modified_for_recompute = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_modified_for_recompute);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_display_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_display_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_display_name_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_display_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->display_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->display_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->display_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_display_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_display_name_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->display_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewstyle_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewstyle_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_flags_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_flags_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_style_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->identifier_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_style_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->identifier_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->identifier_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->identifier_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_height_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->identifier_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_height_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->identifier_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->identifier_exclude_characters);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->identifier_exclude_characters = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->identifier_exclude_characters = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->identifier_exclude_characters);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->identifier_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->identifier_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->identifier_placement = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_placement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->identifier_placement);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_symbol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_symbol);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->arrow_symbol_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->arrow_symbol_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_symbol_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_symbol_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->boundary_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->boundary_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->boundary_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->boundary_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->boundary_line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->boundary_line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->viewlabel_text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->viewlabel_text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->viewlabel_text_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->viewlabel_text_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->viewlabel_text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->viewlabel_text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewlabel_attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewlabel_attachment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->viewlabel_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->viewlabel_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewlabel_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewlabel_alignment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->viewlabel_pattern);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->viewlabel_pattern = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->viewlabel_pattern = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->viewlabel_pattern);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->connection_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->connection_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->connection_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->connection_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->connection_line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_connection_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->connection_line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->borderline_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->borderline_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->borderline_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->borderline_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_borderline_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_color_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->borderline_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_borderline_color_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->borderline_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_model_edge_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DETAILVIEWSTYLE_model_edge_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_model_edge_set" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_DETAILVIEWSTYLE_model_edge_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->model_edge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DETAILVIEWSTYLE_model_edge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DETAILVIEWSTYLE_model_edge_get" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  result = (BITCODE_RC) ((arg1)->model_edge);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DETAILVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DETAILVIEWSTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DETAILVIEWSTYLE *)calloc(1, sizeof(struct _dwg_object_DETAILVIEWSTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DETAILVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DETAILVIEWSTYLE *arg1 = (struct _dwg_object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DETAILVIEWSTYLE" "', argument " "1"" of type '" "struct _dwg_object_DETAILVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_DETAILVIEWSTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DETAILVIEWSTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DETAILVIEWSTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->mdoc_class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->mdoc_class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_desc_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_desc_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_modified_for_recompute = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->is_modified_for_recompute);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_display_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_display_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_display_name_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_display_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->display_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->display_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->display_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_display_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_display_name_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->display_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewstyle_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewstyle_flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_flags_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_flags_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->identifier_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->identifier_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->identifier_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->identifier_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->identifier_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->identifier_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_start_symbol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_start_symbol);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arrow_end_symbol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->arrow_end_symbol);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->arrow_symbol_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->arrow_symbol_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_symbol_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_symbol_size);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->identifier_exclude_characters);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->identifier_exclude_characters = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->identifier_exclude_characters = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->identifier_exclude_characters);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->identifier_position = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->identifier_position);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->identifier_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->identifier_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->arrow_position = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->arrow_position);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->arrow_symbol_extension_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->arrow_symbol_extension_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->plane_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->plane_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->plane_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->plane_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->plane_line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->plane_line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->bend_ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->bend_ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bend_linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bend_linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->bend_line_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->bend_line_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->bend_line_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->bend_line_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_line_overshoot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_line_overshoot);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_line_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_line_length);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->viewlabel_text_style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_H) ((arg1)->viewlabel_text_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->viewlabel_text_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->viewlabel_text_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->viewlabel_text_height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->viewlabel_text_height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewlabel_attachment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewlabel_attachment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->viewlabel_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->viewlabel_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->viewlabel_alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->viewlabel_alignment);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->viewlabel_pattern);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->viewlabel_pattern = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->viewlabel_pattern = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->viewlabel_pattern);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->hatch_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->hatch_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->hatch_bg_color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->hatch_bg_color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->hatch_pattern);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->hatch_pattern = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->hatch_pattern = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_TV) ((arg1)->hatch_pattern);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->hatch_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD) ((arg1)->hatch_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->hatch_transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BLd) ((arg1)->hatch_transparency);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b1);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b2);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_hatch_angles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_hatch_angles);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->hatch_angles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_get" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  result = (BITCODE_BD *) ((arg1)->hatch_angles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SECTIONVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SECTIONVIEWSTYLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SECTIONVIEWSTYLE *)calloc(1, sizeof(struct _dwg_object_SECTIONVIEWSTYLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SECTIONVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTIONVIEWSTYLE *arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SECTIONVIEWSTYLE" "', argument " "1"" of type '" "struct _dwg_object_SECTIONVIEWSTYLE *""'"); 
  }
  arg1 = (struct _dwg_object_SECTIONVIEWSTYLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SECTIONVIEWSTYLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SECTIONVIEWSTYLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_MANAGER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTION_MANAGER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_is_live_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_MANAGER_is_live_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_is_live_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTION_MANAGER_is_live_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_live = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_is_live_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_is_live_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_live);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_num_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_MANAGER_num_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_num_sections_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTION_MANAGER_num_sections_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_num_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_num_sections_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_sections);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_MANAGER_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_sections_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTION_MANAGER_sections_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_MANAGER_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_MANAGER_sections_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  result = (BITCODE_H *) ((arg1)->sections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SECTION_MANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SECTION_MANAGER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SECTION_MANAGER *)calloc(1, sizeof(struct _dwg_object_SECTION_MANAGER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_MANAGER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SECTION_MANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_MANAGER *arg1 = (struct _dwg_object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_MANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SECTION_MANAGER" "', argument " "1"" of type '" "struct _dwg_object_SECTION_MANAGER *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_MANAGER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SECTION_MANAGER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SECTION_MANAGER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SECTION_MANAGER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  struct _dwg_SECTION_typesettings *arg2 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_parent_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SECTION_typesettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_parent_set" "', argument " "2"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg2 = (struct _dwg_SECTION_typesettings *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_SECTION_typesettings *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_parent_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (struct _dwg_SECTION_typesettings *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_num_geoms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_num_geoms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_num_geoms_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_num_geoms_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geoms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_num_geoms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_num_geoms_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geoms);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hexindex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hexindex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hexindex_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_hexindex_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->hexindex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hexindex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hexindex_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BL) ((arg1)->hexindex);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_flags_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_flags_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_color_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_color_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_layer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_layer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_layer_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_layer_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->layer);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->layer = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->layer = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_layer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_layer_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_TV) ((arg1)->layer);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_ltype_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_ltype_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->ltype);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->ltype = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->ltype = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_ltype_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_TV) ((arg1)->ltype);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_ltype_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_ltype_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_ltype_scale_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_ltype_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ltype_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_ltype_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_ltype_scale_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BD) ((arg1)->ltype_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_plotstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_plotstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_plotstyle_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_plotstyle_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->plotstyle);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->plotstyle = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->plotstyle = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_plotstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_plotstyle_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_TV) ((arg1)->plotstyle);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_linewt_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_linewt_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_linewt_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BLd) ((arg1)->linewt);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_face_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_face_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_face_transparency_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_face_transparency_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->face_transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_face_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_face_transparency_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BS) ((arg1)->face_transparency);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_edge_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_edge_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_edge_transparency_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_edge_transparency_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->edge_transparency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_edge_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_edge_transparency_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BS) ((arg1)->edge_transparency);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hatch_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_type_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_hatch_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->hatch_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_type_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BS) ((arg1)->hatch_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_pattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hatch_pattern_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_pattern_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_geometrysettings_hatch_pattern_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->hatch_pattern);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->hatch_pattern = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->hatch_pattern = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_pattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_pattern_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_TV) ((arg1)->hatch_pattern);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hatch_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_angle_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_hatch_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->hatch_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_angle_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BD) ((arg1)->hatch_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hatch_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_spacing_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_hatch_spacing_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->hatch_spacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_spacing_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BD) ((arg1)->hatch_spacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_geometrysettings_hatch_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_scale_set" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_geometrysettings_hatch_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->hatch_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_geometrysettings_hatch_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_geometrysettings_hatch_scale_get" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  result = (BITCODE_BD) ((arg1)->hatch_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SECTION_geometrysettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SECTION_geometrysettings", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_SECTION_geometrysettings *)calloc(1, sizeof(struct _dwg_SECTION_geometrysettings));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SECTION_geometrysettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SECTION_geometrysettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_geometrysettings *arg1 = (struct _dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_geometrysettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SECTION_geometrysettings" "', argument " "1"" of type '" "struct _dwg_SECTION_geometrysettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_geometrysettings *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SECTION_geometrysettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_SECTION_geometrysettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SECTION_geometrysettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  struct _dwg_object_SECTION_SETTINGS *arg2 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_parent_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_typesettings_parent_set" "', argument " "2"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg2 = (struct _dwg_object_SECTION_SETTINGS *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_SECTION_SETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_parent_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (struct _dwg_object_SECTION_SETTINGS *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_type_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_typesettings_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_type_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_generation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_generation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_generation_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_typesettings_generation_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->generation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_generation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_generation_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_BS) ((arg1)->generation);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_num_sources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_num_sources_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_num_sources_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_typesettings_num_sources_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_sources = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_num_sources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_num_sources_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_sources);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_sources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_sources_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_sources_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_typesettings_sources_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->sources = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_sources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_sources_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_H *) ((arg1)->sources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_destblock_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_destblock_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_destblock_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_typesettings_destblock_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->destblock = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_destblock_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_destblock_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_H) ((arg1)->destblock);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_destfile_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_destfile_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_destfile_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_typesettings_destfile_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->destfile);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->destfile = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->destfile = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_destfile_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_destfile_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_TV) ((arg1)->destfile);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_num_geom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_num_geom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_num_geom_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SECTION_typesettings_num_geom_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_geom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_num_geom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_num_geom_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_geom);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_geom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  Dwg_SECTION_geometrysettings *arg2 = (Dwg_SECTION_geometrysettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SECTION_typesettings_geom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_geom_set" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SECTION_geometrysettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SECTION_typesettings_geom_set" "', argument " "2"" of type '" "Dwg_SECTION_geometrysettings *""'"); 
  }
  arg2 = (Dwg_SECTION_geometrysettings *)(argp2);
  if (arg1) (arg1)->geom = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SECTION_typesettings_geom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SECTION_geometrysettings *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SECTION_typesettings_geom_get" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  result = (Dwg_SECTION_geometrysettings *) ((arg1)->geom);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SECTION_geometrysettings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SECTION_typesettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SECTION_typesettings", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_SECTION_typesettings *)calloc(1, sizeof(struct _dwg_SECTION_typesettings));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SECTION_typesettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SECTION_typesettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SECTION_typesettings *arg1 = (struct _dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SECTION_typesettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SECTION_typesettings" "', argument " "1"" of type '" "struct _dwg_SECTION_typesettings *""'"); 
  }
  arg1 = (struct _dwg_SECTION_typesettings *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SECTION_typesettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_SECTION_typesettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SECTION_typesettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_SETTINGS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTION_SETTINGS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_curr_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_SETTINGS_curr_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_curr_type_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTION_SETTINGS_curr_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->curr_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_curr_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_curr_type_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  result = (BITCODE_BS) ((arg1)->curr_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_num_types_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_SETTINGS_num_types_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_num_types_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_SECTION_SETTINGS_num_types_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_types = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_num_types_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_num_types_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_types);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_types_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  Dwg_SECTION_typesettings *arg2 = (Dwg_SECTION_typesettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_SECTION_SETTINGS_types_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_types_set" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SECTION_typesettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_SECTION_SETTINGS_types_set" "', argument " "2"" of type '" "Dwg_SECTION_typesettings *""'"); 
  }
  arg2 = (Dwg_SECTION_typesettings *)(argp2);
  if (arg1) (arg1)->types = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_SECTION_SETTINGS_types_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SECTION_typesettings *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_SECTION_SETTINGS_types_get" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  result = (Dwg_SECTION_typesettings *) ((arg1)->types);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SECTION_typesettings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_SECTION_SETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_SECTION_SETTINGS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_SECTION_SETTINGS *)calloc(1, sizeof(struct _dwg_object_SECTION_SETTINGS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_SETTINGS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_SECTION_SETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_SECTION_SETTINGS *arg1 = (struct _dwg_object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_SECTION_SETTINGS" "', argument " "1"" of type '" "struct _dwg_object_SECTION_SETTINGS *""'"); 
  }
  arg1 = (struct _dwg_object_SECTION_SETTINGS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_SECTION_SETTINGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_SECTION_SETTINGS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_SECTION_SETTINGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYERFILTER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYERFILTER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_num_names_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYERFILTER_num_names_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_num_names_set" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_LAYERFILTER_num_names_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_names = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_num_names_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_num_names_get" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_names);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_names_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_LAYERFILTER_names_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_names_set" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_LAYERFILTER_names_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->names = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_LAYERFILTER_names_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_LAYERFILTER_names_get" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  result = (BITCODE_TV *) ((arg1)->names);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_LAYERFILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_LAYERFILTER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_LAYERFILTER *)calloc(1, sizeof(struct _dwg_object_LAYERFILTER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYERFILTER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_LAYERFILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_LAYERFILTER *arg1 = (struct _dwg_object_LAYERFILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_LAYERFILTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_LAYERFILTER" "', argument " "1"" of type '" "struct _dwg_object_LAYERFILTER *""'"); 
  }
  arg1 = (struct _dwg_object_LAYERFILTER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_LAYERFILTER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_LAYERFILTER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_LAYERFILTER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_text_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_size_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_size_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->text_size);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_size = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_size = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_size_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->text_size);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_xscale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_xscale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_xscale_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_xscale_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->xscale);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->xscale = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->xscale = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_xscale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_xscale_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->xscale);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->char_spacing);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->char_spacing = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->char_spacing = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_char_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->char_spacing);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_style_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_style_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->style);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->style = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->style = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_style_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->style);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_value_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_value_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_font_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_font_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_font_name_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_font_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->font_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->font_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->font_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_font_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_font_name_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->font_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->bigfont_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->bigfont_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->bigfont_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->bigfont_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->offset_from_arc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->offset_from_arc = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->offset_from_arc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->offset_from_arc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_right_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_right_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_right_offset_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_right_offset_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->right_offset);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->right_offset = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->right_offset = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_right_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_right_offset_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->right_offset);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_left_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_D2T arg2 = (BITCODE_D2T) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_left_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_left_offset_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_left_offset_set" "', argument " "2"" of type '" "BITCODE_D2T""'");
  }
  arg2 = (BITCODE_D2T)(buf2);
  free((char*)arg1->left_offset);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->left_offset = (BITCODE_D2T)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->left_offset = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_left_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_D2T result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_left_offset_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_D2T) ((arg1)->left_offset);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_center_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_center_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_center_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_radius_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_radius_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->radius = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_radius_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->radius);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_start_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_start_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_start_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_start_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->start_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_start_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_start_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->start_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_end_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_end_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_end_angle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_end_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->end_angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_end_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_end_angle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->end_angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_extrusion_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_color_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_color_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->color = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_color_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BL) ((arg1)->color);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_reverse = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_reverse_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_reverse);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_text_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_direction_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_direction_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_direction_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_direction);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_alignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_alignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_alignment_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_alignment_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->alignment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_alignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_alignment_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->alignment);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_text_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_position_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_position_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->text_position = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_text_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_text_position_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->text_position);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_bold_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_is_bold_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_bold_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_bold_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_bold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_bold_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_bold_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_bold);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_italic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_is_italic_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_italic_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_italic_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_italic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_italic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_italic_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_italic);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_underlined = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_underlined_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_underlined);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_character_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_character_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_character_set_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_character_set_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->character_set = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_character_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_character_set_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->character_set);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->pitch_and_family = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->pitch_and_family);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_shx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_is_shx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_shx_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_shx_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->is_shx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_is_shx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_is_shx_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->is_shx);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->wizard_flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->wizard_flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->arc_handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ARCALIGNEDTEXT_arc_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_get" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  result = (BITCODE_H) ((arg1)->arc_handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ARCALIGNEDTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ARCALIGNEDTEXT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ARCALIGNEDTEXT *)calloc(1, sizeof(struct _dwg_entity_ARCALIGNEDTEXT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ARCALIGNEDTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ARCALIGNEDTEXT *arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ARCALIGNEDTEXT" "', argument " "1"" of type '" "struct _dwg_entity_ARCALIGNEDTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_ARCALIGNEDTEXT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ARCALIGNEDTEXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ARCALIGNEDTEXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RTEXT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_pt_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RTEXT_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_pt_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_BE *arg2 = (BITCODE_BE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RTEXT_extrusion_set" "', argument " "2"" of type '" "BITCODE_BE *""'"); 
  }
  arg2 = (BITCODE_BE *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_BE *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_rotation_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_RTEXT_rotation_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->rotation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_rotation_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->rotation);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_height_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_RTEXT_height_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->height = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_height_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_BD) ((arg1)->height);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_flags_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_RTEXT_flags_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_flags_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_BS) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_text_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_text_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_text_value_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RTEXT_text_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->text_value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->text_value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->text_value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_text_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_text_value_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_TV) ((arg1)->text_value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_RTEXT_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_style_set" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_RTEXT_style_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->style = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_RTEXT_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_RTEXT_style_get" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  result = (BITCODE_H) ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_RTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_RTEXT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_RTEXT *)calloc(1, sizeof(struct _dwg_entity_RTEXT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RTEXT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_RTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_RTEXT *arg1 = (struct _dwg_entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_RTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_RTEXT" "', argument " "1"" of type '" "struct _dwg_entity_RTEXT *""'"); 
  }
  arg1 = (struct _dwg_entity_RTEXT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_RTEXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_RTEXT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_RTEXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LAYOUTPRINTCONFIG_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LAYOUTPRINTCONFIG_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_flag_set" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LAYOUTPRINTCONFIG_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LAYOUTPRINTCONFIG_flag_get" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LAYOUTPRINTCONFIG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LAYOUTPRINTCONFIG", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LAYOUTPRINTCONFIG *)calloc(1, sizeof(struct _dwg_entity_LAYOUTPRINTCONFIG));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LAYOUTPRINTCONFIG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LAYOUTPRINTCONFIG *arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LAYOUTPRINTCONFIG" "', argument " "1"" of type '" "struct _dwg_entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg1 = (struct _dwg_entity_LAYOUTPRINTCONFIG *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LAYOUTPRINTCONFIG_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LAYOUTPRINTCONFIG_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACMECOMMANDHISTORY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMECOMMANDHISTORY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACMECOMMANDHISTORY *""'"); 
  }
  arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMECOMMANDHISTORY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACMECOMMANDHISTORY *""'"); 
  }
  arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMECOMMANDHISTORY_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMECOMMANDHISTORY_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ACMECOMMANDHISTORY *""'"); 
  }
  arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMECOMMANDHISTORY_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMECOMMANDHISTORY_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ACMECOMMANDHISTORY *""'"); 
  }
  arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACMECOMMANDHISTORY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACMECOMMANDHISTORY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACMECOMMANDHISTORY *)calloc(1, sizeof(struct _dwg_object_ACMECOMMANDHISTORY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACMECOMMANDHISTORY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMECOMMANDHISTORY *arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACMECOMMANDHISTORY" "', argument " "1"" of type '" "struct _dwg_object_ACMECOMMANDHISTORY *""'"); 
  }
  arg1 = (struct _dwg_object_ACMECOMMANDHISTORY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACMECOMMANDHISTORY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACMECOMMANDHISTORY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESCOPE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *arg1 = (struct _dwg_object_ACMESCOPE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMESCOPE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESCOPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESCOPE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACMESCOPE *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESCOPE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACMESCOPE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESCOPE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *arg1 = (struct _dwg_object_ACMESCOPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESCOPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESCOPE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACMESCOPE *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESCOPE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESCOPE_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *arg1 = (struct _dwg_object_ACMESCOPE *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMESCOPE_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESCOPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESCOPE_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ACMESCOPE *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESCOPE *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACMESCOPE_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESCOPE_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *arg1 = (struct _dwg_object_ACMESCOPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESCOPE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESCOPE_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ACMESCOPE *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESCOPE *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACMESCOPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACMESCOPE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACMESCOPE *)calloc(1, sizeof(struct _dwg_object_ACMESCOPE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMESCOPE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACMESCOPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESCOPE *arg1 = (struct _dwg_object_ACMESCOPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESCOPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACMESCOPE" "', argument " "1"" of type '" "struct _dwg_object_ACMESCOPE *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESCOPE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACMESCOPE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACMESCOPE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACMESCOPE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESTATEMGR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *arg1 = (struct _dwg_object_ACMESTATEMGR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMESTATEMGR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESTATEMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESTATEMGR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_ACMESTATEMGR *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESTATEMGR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_ACMESTATEMGR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESTATEMGR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *arg1 = (struct _dwg_object_ACMESTATEMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESTATEMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESTATEMGR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_ACMESTATEMGR *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESTATEMGR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESTATEMGR_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *arg1 = (struct _dwg_object_ACMESTATEMGR *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_ACMESTATEMGR_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESTATEMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESTATEMGR_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_ACMESTATEMGR *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESTATEMGR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_ACMESTATEMGR_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_ACMESTATEMGR_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *arg1 = (struct _dwg_object_ACMESTATEMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESTATEMGR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_ACMESTATEMGR_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_ACMESTATEMGR *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESTATEMGR *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_ACMESTATEMGR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_ACMESTATEMGR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_ACMESTATEMGR *)calloc(1, sizeof(struct _dwg_object_ACMESTATEMGR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMESTATEMGR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_ACMESTATEMGR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_ACMESTATEMGR *arg1 = (struct _dwg_object_ACMESTATEMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ACMESTATEMGR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_ACMESTATEMGR" "', argument " "1"" of type '" "struct _dwg_object_ACMESTATEMGR *""'"); 
  }
  arg1 = (struct _dwg_object_ACMESTATEMGR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_ACMESTATEMGR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_ACMESTATEMGR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_ACMESTATEMGR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_CSACDOCUMENTOPTIONS_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CSACDOCUMENTOPTIONS_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_parent_set" "', argument " "1"" of type '" "struct _dwg_object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CSACDOCUMENTOPTIONS_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_parent_get" "', argument " "1"" of type '" "struct _dwg_object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_CSACDOCUMENTOPTIONS_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_CSACDOCUMENTOPTIONS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_CSACDOCUMENTOPTIONS", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_CSACDOCUMENTOPTIONS *)calloc(1, sizeof(struct _dwg_object_CSACDOCUMENTOPTIONS));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_CSACDOCUMENTOPTIONS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_CSACDOCUMENTOPTIONS *arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_CSACDOCUMENTOPTIONS" "', argument " "1"" of type '" "struct _dwg_object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg1 = (struct _dwg_object_CSACDOCUMENTOPTIONS *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_CSACDOCUMENTOPTIONS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_CSACDOCUMENTOPTIONS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_connection_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *arg1 = (struct _dwg_BLOCKPARAMETER_connection *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMETER_connection_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_connection_code_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_connection *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMETER_connection_code_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_connection_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *arg1 = (struct _dwg_BLOCKPARAMETER_connection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_connection_code_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_connection *)(argp1);
  result = (BITCODE_BL) ((arg1)->code);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_connection_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *arg1 = (struct _dwg_BLOCKPARAMETER_connection *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMETER_connection_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_connection_name_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_connection *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKPARAMETER_connection_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_connection_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *arg1 = (struct _dwg_BLOCKPARAMETER_connection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_connection_name_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_connection *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKPARAMETER_connection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKPARAMETER_connection", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKPARAMETER_connection *)calloc(1, sizeof(struct _dwg_BLOCKPARAMETER_connection));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKPARAMETER_connection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_connection *arg1 = (struct _dwg_BLOCKPARAMETER_connection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKPARAMETER_connection" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_connection *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKPARAMETER_connection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKPARAMETER_connection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_PropInfo_num_connections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMETER_PropInfo_num_connections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_num_connections_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_num_connections_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_connections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_PropInfo_num_connections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_num_connections_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_connections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_PropInfo_connections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  Dwg_BLOCKPARAMETER_connection *arg2 = (Dwg_BLOCKPARAMETER_connection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMETER_PropInfo_connections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_connections_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_connections_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_connection *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_connection *)(argp2);
  if (arg1) (arg1)->connections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMETER_PropInfo_connections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_connection *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMETER_PropInfo_connections_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *)(argp1);
  result = (Dwg_BLOCKPARAMETER_connection *) ((arg1)->connections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_connection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKPARAMETER_PropInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKPARAMETER_PropInfo", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKPARAMETER_PropInfo *)calloc(1, sizeof(struct _dwg_BLOCKPARAMETER_PropInfo));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKPARAMETER_PropInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMETER_PropInfo *arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKPARAMETER_PropInfo" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMETER_PropInfo *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKPARAMETER_PropInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKPARAMETER_PropInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_desc_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKPARAMVALUESET_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_desc_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_TV) ((arg1)->desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_flags_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMVALUESET_flags_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_flags_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_minimum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_minimum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_minimum_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMVALUESET_minimum_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->minimum = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_minimum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_minimum_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BD) ((arg1)->minimum);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_maximum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_maximum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_maximum_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMVALUESET_maximum_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->maximum = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_maximum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_maximum_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BD) ((arg1)->maximum);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_increment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_increment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_increment_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMVALUESET_increment_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->increment = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_increment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_increment_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BD) ((arg1)->increment);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_num_valuelist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_num_valuelist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_num_valuelist_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKPARAMVALUESET_num_valuelist_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_valuelist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_num_valuelist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_num_valuelist_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_valuelist);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_valuelist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  BITCODE_BD *arg2 = (BITCODE_BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKPARAMVALUESET_valuelist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_valuelist_set" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKPARAMVALUESET_valuelist_set" "', argument " "2"" of type '" "BITCODE_BD *""'"); 
  }
  arg2 = (BITCODE_BD *)(argp2);
  if (arg1) (arg1)->valuelist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKPARAMVALUESET_valuelist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKPARAMVALUESET_valuelist_get" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  result = (BITCODE_BD *) ((arg1)->valuelist);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKPARAMVALUESET(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKPARAMVALUESET", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKPARAMVALUESET *)calloc(1, sizeof(struct _dwg_BLOCKPARAMVALUESET));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKPARAMVALUESET(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKPARAMVALUESET *arg1 = (struct _dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKPARAMVALUESET" "', argument " "1"" of type '" "struct _dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg1 = (struct _dwg_BLOCKPARAMVALUESET *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKPARAMVALUESET_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKPARAMVALUESET_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKACTION_connectionpts_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *arg1 = (struct _dwg_BLOCKACTION_connectionpts *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKACTION_connectionpts_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKACTION_connectionpts_code_set" "', argument " "1"" of type '" "struct _dwg_BLOCKACTION_connectionpts *""'"); 
  }
  arg1 = (struct _dwg_BLOCKACTION_connectionpts *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKACTION_connectionpts_code_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKACTION_connectionpts_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *arg1 = (struct _dwg_BLOCKACTION_connectionpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKACTION_connectionpts_code_get" "', argument " "1"" of type '" "struct _dwg_BLOCKACTION_connectionpts *""'"); 
  }
  arg1 = (struct _dwg_BLOCKACTION_connectionpts *)(argp1);
  result = (BITCODE_BL) ((arg1)->code);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKACTION_connectionpts_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *arg1 = (struct _dwg_BLOCKACTION_connectionpts *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKACTION_connectionpts_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKACTION_connectionpts_name_set" "', argument " "1"" of type '" "struct _dwg_BLOCKACTION_connectionpts *""'"); 
  }
  arg1 = (struct _dwg_BLOCKACTION_connectionpts *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKACTION_connectionpts_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKACTION_connectionpts_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *arg1 = (struct _dwg_BLOCKACTION_connectionpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKACTION_connectionpts_name_get" "', argument " "1"" of type '" "struct _dwg_BLOCKACTION_connectionpts *""'"); 
  }
  arg1 = (struct _dwg_BLOCKACTION_connectionpts *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKACTION_connectionpts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKACTION_connectionpts", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKACTION_connectionpts *)calloc(1, sizeof(struct _dwg_BLOCKACTION_connectionpts));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKACTION_connectionpts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKACTION_connectionpts *arg1 = (struct _dwg_BLOCKACTION_connectionpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKACTION_connectionpts" "', argument " "1"" of type '" "struct _dwg_BLOCKACTION_connectionpts *""'"); 
  }
  arg1 = (struct _dwg_BLOCKACTION_connectionpts *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKACTION_connectionpts_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKACTION_connectionpts_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg2 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set" "', argument " "2"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg2 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_name_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_name_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (BITCODE_H *) ((arg1)->blocks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_params);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_params_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKVISIBILITYPARAMETER_state_params_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_params_set" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_params_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->params = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKVISIBILITYPARAMETER_state_params_get" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  result = (BITCODE_H *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKVISIBILITYPARAMETER_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKVISIBILITYPARAMETER_state", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)calloc(1, sizeof(struct _dwg_BLOCKVISIBILITYPARAMETER_state));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKVISIBILITYPARAMETER_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKVISIBILITYPARAMETER_state *arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKVISIBILITYPARAMETER_state" "', argument " "1"" of type '" "struct _dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg1 = (struct _dwg_BLOCKVISIBILITYPARAMETER_state *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKVISIBILITYPARAMETER_state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKVISIBILITYPARAMETER_state_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_propinfos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_propinfos);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_initialized = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->is_initialized);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_bool = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_bool);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->blockvisi_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->blockvisi_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->blockvisi_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->blockvisi_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->blockvisi_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->blockvisi_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->blockvisi_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->blockvisi_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_blocks);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->blocks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_H *) ((arg1)->blocks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_states);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  Dwg_BLOCKVISIBILITYPARAMETER_state *arg2 = (Dwg_BLOCKVISIBILITYPARAMETER_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set" "', argument " "2"" of type '" "Dwg_BLOCKVISIBILITYPARAMETER_state *""'"); 
  }
  arg2 = (Dwg_BLOCKVISIBILITYPARAMETER_state *)(argp2);
  if (arg1) (arg1)->states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKVISIBILITYPARAMETER_state *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  result = (Dwg_BLOCKVISIBILITYPARAMETER_state *) ((arg1)->states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKVISIBILITYPARAMETER_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKVISIBILITYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKVISIBILITYPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKVISIBILITYPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKVISIBILITYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYPARAMETER *arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKVISIBILITYPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKVISIBILITYPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKVISIBILITYPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKVISIBILITYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKVISIBILITYGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKVISIBILITYGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKVISIBILITYGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKVISIBILITYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVISIBILITYGRIP *arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKVISIBILITYGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVISIBILITYGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKVISIBILITYGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKVISIBILITYGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->grip_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  result = (BITCODE_BL) ((arg1)->grip_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->grip_expr);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->grip_expr = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->grip_expr = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  result = (BITCODE_TV) ((arg1)->grip_expr);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)calloc(1, sizeof(struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT" "', argument " "1"" of type '" "struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BREAKDATA_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BREAKDATA_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_num_pointrefs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BREAKDATA_num_pointrefs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_num_pointrefs_set" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BREAKDATA_num_pointrefs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_pointrefs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_num_pointrefs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_num_pointrefs_get" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_pointrefs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_pointrefs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BREAKDATA_pointrefs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_pointrefs_set" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BREAKDATA_pointrefs_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->pointrefs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_pointrefs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_pointrefs_get" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  result = (BITCODE_H *) ((arg1)->pointrefs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_dimref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BREAKDATA_dimref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_dimref_set" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BREAKDATA_dimref_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dimref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKDATA_dimref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKDATA_dimref_get" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  result = (BITCODE_H) ((arg1)->dimref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BREAKDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BREAKDATA", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BREAKDATA *)calloc(1, sizeof(struct _dwg_object_BREAKDATA));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BREAKDATA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BREAKDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKDATA *arg1 = (struct _dwg_object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BREAKDATA" "', argument " "1"" of type '" "struct _dwg_object_BREAKDATA *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKDATA *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BREAKDATA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BREAKDATA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BREAKDATA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKPOINTREF_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKPOINTREF *arg1 = (struct _dwg_object_BREAKPOINTREF *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BREAKPOINTREF_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKPOINTREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKPOINTREF_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BREAKPOINTREF *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKPOINTREF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BREAKPOINTREF_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BREAKPOINTREF_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKPOINTREF *arg1 = (struct _dwg_object_BREAKPOINTREF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKPOINTREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BREAKPOINTREF_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BREAKPOINTREF *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKPOINTREF *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BREAKPOINTREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKPOINTREF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BREAKPOINTREF", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BREAKPOINTREF *)calloc(1, sizeof(struct _dwg_object_BREAKPOINTREF));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BREAKPOINTREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BREAKPOINTREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BREAKPOINTREF *arg1 = (struct _dwg_object_BREAKPOINTREF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BREAKPOINTREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BREAKPOINTREF" "', argument " "1"" of type '" "struct _dwg_object_BREAKPOINTREF *""'"); 
  }
  arg1 = (struct _dwg_object_BREAKPOINTREF *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BREAKPOINTREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BREAKPOINTREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BREAKPOINTREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_FLIPGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPGRIPENTITY *arg1 = (struct _dwg_entity_FLIPGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_FLIPGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_FLIPGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_FLIPGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_FLIPGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_FLIPGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPGRIPENTITY *arg1 = (struct _dwg_entity_FLIPGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_FLIPGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_FLIPGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_FLIPGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_FLIPGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_FLIPGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_FLIPGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_FLIPGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPGRIPENTITY *arg1 = (struct _dwg_entity_FLIPGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_FLIPGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_FLIPGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_FLIPGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_FLIPGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LINEARGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARGRIPENTITY *arg1 = (struct _dwg_entity_LINEARGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINEARGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINEARGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LINEARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINEARGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINEARGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARGRIPENTITY *arg1 = (struct _dwg_entity_LINEARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINEARGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LINEARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LINEARGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LINEARGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LINEARGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_LINEARGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LINEARGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARGRIPENTITY *arg1 = (struct _dwg_entity_LINEARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LINEARGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_LINEARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LINEARGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LINEARGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POLARGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLARGRIPENTITY *arg1 = (struct _dwg_entity_POLARGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POLARGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLARGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POLARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POLARGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POLARGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POLARGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLARGRIPENTITY *arg1 = (struct _dwg_entity_POLARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POLARGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POLARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POLARGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POLARGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLARGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POLARGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POLARGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_POLARGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POLARGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POLARGRIPENTITY *arg1 = (struct _dwg_entity_POLARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POLARGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_POLARGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POLARGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POLARGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POLARGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ROTATIONGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONGRIPENTITY *arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ROTATIONGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ROTATIONGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ROTATIONGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ROTATIONGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONGRIPENTITY *arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ROTATIONGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ROTATIONGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ROTATIONGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ROTATIONGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_ROTATIONGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ROTATIONGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONGRIPENTITY *arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ROTATIONGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ROTATIONGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ROTATIONGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VISIBILITYGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYGRIPENTITY *arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VISIBILITYGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VISIBILITYGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VISIBILITYGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VISIBILITYGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYGRIPENTITY *arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VISIBILITYGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VISIBILITYGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VISIBILITYGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VISIBILITYGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_VISIBILITYGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VISIBILITYGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYGRIPENTITY *arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VISIBILITYGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VISIBILITYGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VISIBILITYGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_XYGRIPENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYGRIPENTITY *arg1 = (struct _dwg_entity_XYGRIPENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_XYGRIPENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_XYGRIPENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_XYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYGRIPENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_XYGRIPENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_XYGRIPENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYGRIPENTITY *arg1 = (struct _dwg_entity_XYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYGRIPENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_XYGRIPENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_XYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYGRIPENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_XYGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_XYGRIPENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_XYGRIPENTITY *)calloc(1, sizeof(struct _dwg_entity_XYGRIPENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_XYGRIPENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_XYGRIPENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYGRIPENTITY *arg1 = (struct _dwg_entity_XYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_XYGRIPENTITY" "', argument " "1"" of type '" "struct _dwg_entity_XYGRIPENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYGRIPENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_XYGRIPENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_XYGRIPENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_XYGRIPENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ALIGNMENTPARAMETERENTITY *arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ALIGNMENTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ALIGNMENTPARAMETERENTITY *arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ALIGNMENTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ALIGNMENTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ALIGNMENTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ALIGNMENTPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_ALIGNMENTPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ALIGNMENTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ALIGNMENTPARAMETERENTITY *arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ALIGNMENTPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_ALIGNMENTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ALIGNMENTPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ALIGNMENTPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ALIGNMENTPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BASEPOINTPARAMETERENTITY *arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_BASEPOINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BASEPOINTPARAMETERENTITY *arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_BASEPOINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_BASEPOINTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BASEPOINTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_BASEPOINTPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_BASEPOINTPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_BASEPOINTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_BASEPOINTPARAMETERENTITY *arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_BASEPOINTPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_BASEPOINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_BASEPOINTPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_BASEPOINTPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_BASEPOINTPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_FLIPPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPPARAMETERENTITY *arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_FLIPPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_FLIPPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_FLIPPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_FLIPPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_FLIPPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPPARAMETERENTITY *arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_FLIPPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_FLIPPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_FLIPPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_FLIPPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_FLIPPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_FLIPPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_FLIPPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_FLIPPARAMETERENTITY *arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_FLIPPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_FLIPPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_FLIPPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_FLIPPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_FLIPPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LINEARPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARPARAMETERENTITY *arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LINEARPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINEARPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LINEARPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LINEARPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LINEARPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARPARAMETERENTITY *arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LINEARPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LINEARPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LINEARPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LINEARPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LINEARPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_LINEARPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LINEARPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LINEARPARAMETERENTITY *arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LINEARPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_LINEARPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_LINEARPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LINEARPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LINEARPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTPARAMETERENTITY *arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTPARAMETERENTITY *arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POINTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POINTPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POINTPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_POINTPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POINTPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTPARAMETERENTITY *arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POINTPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_POINTPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POINTPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POINTPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONPARAMETERENTITY *arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ROTATIONPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONPARAMETERENTITY *arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ROTATIONPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ROTATIONPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ROTATIONPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_ROTATIONPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ROTATIONPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ROTATIONPARAMETERENTITY *arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ROTATIONPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_ROTATIONPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_ROTATIONPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ROTATIONPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ROTATIONPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYPARAMETERENTITY *arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYPARAMETERENTITY *arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_VISIBILITYPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_VISIBILITYPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_VISIBILITYPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_VISIBILITYPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_VISIBILITYPARAMETERENTITY *arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_VISIBILITYPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_VISIBILITYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_VISIBILITYPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_VISIBILITYPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_VISIBILITYPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_XYPARAMETERENTITY_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYPARAMETERENTITY *arg1 = (struct _dwg_entity_XYPARAMETERENTITY *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_XYPARAMETERENTITY_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_XYPARAMETERENTITY_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_XYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYPARAMETERENTITY *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_XYPARAMETERENTITY_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_XYPARAMETERENTITY_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYPARAMETERENTITY *arg1 = (struct _dwg_entity_XYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_XYPARAMETERENTITY_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_XYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYPARAMETERENTITY *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_XYPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_XYPARAMETERENTITY", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_XYPARAMETERENTITY *)calloc(1, sizeof(struct _dwg_entity_XYPARAMETERENTITY));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_XYPARAMETERENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_XYPARAMETERENTITY *arg1 = (struct _dwg_entity_XYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_XYPARAMETERENTITY" "', argument " "1"" of type '" "struct _dwg_entity_XYPARAMETERENTITY *""'"); 
  }
  arg1 = (struct _dwg_entity_XYPARAMETERENTITY *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_XYPARAMETERENTITY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_XYPARAMETERENTITY_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTGRIP_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKALIGNMENTGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKALIGNMENTGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKALIGNMENTGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKALIGNMENTGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKALIGNMENTGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTGRIP *arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKALIGNMENTGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNMENTGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNMENTGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->align_perpendicular = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->align_perpendicular);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKALIGNMENTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKALIGNMENTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKALIGNMENTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKALIGNMENTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNMENTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKALIGNMENTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNMENTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNMENTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNMENTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->center_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->center_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->end_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->end_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->orientation_on_both_grips = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->orientation_on_both_grips);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->orientation_on_both_grips = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->orientation_on_both_grips);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKARRAYACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [4]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_column_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_column_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_column_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_column_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->column_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_column_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_column_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->column_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_row_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKARRAYACTION_row_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_row_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKARRAYACTION_row_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->row_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKARRAYACTION_row_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKARRAYACTION_row_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->row_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKARRAYACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKARRAYACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKARRAYACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKARRAYACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKARRAYACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKARRAYACTION *arg1 = (struct _dwg_object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKARRAYACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKARRAYACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKARRAYACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKARRAYACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKARRAYACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_propinfos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_propinfos);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKBASEPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKBASEPOINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKBASEPOINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKBASEPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKBASEPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKBASEPOINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKBASEPOINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKBASEPOINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKBASEPOINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [4]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_action_offset_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_x_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_x_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_action_offset_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_y_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_action_offset_y_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_angle_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPACTION_angle_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_angle_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPACTION_angle_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPACTION_angle_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPACTION_angle_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKFLIPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKFLIPACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKFLIPACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKFLIPACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKFLIPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPACTION *arg1 = (struct _dwg_object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKFLIPACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_combined_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_combined_state_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_combined_state_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_combined_state_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->combined_state = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_combined_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_combined_state_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->combined_state);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_orientation_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_orientation_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_orientation_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_upd_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_upd_state_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_upd_state_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_upd_state_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->upd_state = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_upd_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_upd_state_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BS) ((arg1)->upd_state);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_state_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPGRIP_state_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_state_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPGRIP_state_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->state = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPGRIP_state_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPGRIP_state_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  result = (BITCODE_BS) ((arg1)->state);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKFLIPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKFLIPGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKFLIPGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKFLIPGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKFLIPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPGRIP *arg1 = (struct _dwg_object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKFLIPGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->flip_label);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->flip_label = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->flip_label = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->flip_label);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->flip_label_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->flip_label_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->flip_label_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->flip_label_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->base_state_label);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->base_state_label = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->base_state_label = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->base_state_label);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->flipped_state_label);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->flipped_state_label = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->flipped_state_label = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->flipped_state_label);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_label_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_label_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_bl96_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_bl96_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_bl96_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_bl96_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl96 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_bl96_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_bl96_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl96);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tooltip);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tooltip = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tooltip = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKFLIPPARAMETER_tooltip_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->tooltip);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKFLIPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKFLIPPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKFLIPPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKFLIPPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKFLIPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKFLIPPARAMETER *arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKFLIPPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKFLIPPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKFLIPPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->dependency = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->dependency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr_description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr_description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr_description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr_description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARGRIP_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_orientation_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARGRIP_orientation_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARGRIP_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARGRIP_orientation_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLINEARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLINEARGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLINEARGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKLINEARGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLINEARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARGRIP *arg1 = (struct _dwg_object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLINEARGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->distance_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->distance_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->distance_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->distance_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->distance_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->distance_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->distance_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->distance_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_distance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->distance = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_distance_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->distance);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLINEARPARAMETER_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLINEARPARAMETER_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLINEARPARAMETER_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLINEARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLINEARPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLINEARPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKLINEARPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLINEARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLINEARPARAMETER *arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLINEARPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLINEARPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLINEARPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  struct _dwg_object_BLOCKLOOKUPACTION *arg2 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKLOOKUPACTION_lut_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_parent_set" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_parent_set" "', argument " "2"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg2 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_BLOCKLOOKUPACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_parent_get" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  result = (struct _dwg_object_BLOCKLOOKUPACTION *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [3]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_b282_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKLOOKUPACTION_lut_b282_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b282_set" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b282_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b282 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_b282_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b282_get" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  result = (BITCODE_B) ((arg1)->b282);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_b281_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKLOOKUPACTION_lut_b281_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b281_set" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b281_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b281 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKLOOKUPACTION_lut_b281_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKLOOKUPACTION_lut_b281_get" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  result = (BITCODE_B) ((arg1)->b281);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKLOOKUPACTION_lut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKLOOKUPACTION_lut", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKLOOKUPACTION_lut *)calloc(1, sizeof(struct _dwg_BLOCKLOOKUPACTION_lut));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKLOOKUPACTION_lut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKLOOKUPACTION_lut *arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKLOOKUPACTION_lut" "', argument " "1"" of type '" "struct _dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg1 = (struct _dwg_BLOCKLOOKUPACTION_lut *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKLOOKUPACTION_lut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKLOOKUPACTION_lut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numelems_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_numelems_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numelems_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numelems_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numelems = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numelems_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numelems_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->numelems);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numrows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_numrows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numrows_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numrows_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numrows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numrows_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->numrows);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numcols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_numcols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numcols_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numcols_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->numcols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_numcols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_numcols_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->numcols);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_lut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  Dwg_BLOCKLOOKUPACTION_lut *arg2 = (Dwg_BLOCKLOOKUPACTION_lut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_lut_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_lut_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_lut_set" "', argument " "2"" of type '" "Dwg_BLOCKLOOKUPACTION_lut *""'"); 
  }
  arg2 = (Dwg_BLOCKLOOKUPACTION_lut *)(argp2);
  if (arg1) (arg1)->lut = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_lut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKLOOKUPACTION_lut *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_lut_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (Dwg_BLOCKLOOKUPACTION_lut *) ((arg1)->lut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKLOOKUPACTION_lut, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_exprs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_exprs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_exprs_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_exprs_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->exprs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_exprs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_exprs_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_TV *) ((arg1)->exprs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_b280_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPACTION_b280_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_b280_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_b280_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->b280 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPACTION_b280_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPACTION_b280_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  result = (BITCODE_B) ((arg1)->b280);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLOOKUPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLOOKUPACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLOOKUPACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKLOOKUPACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLOOKUPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPACTION *arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLOOKUPACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLOOKUPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLOOKUPGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLOOKUPGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKLOOKUPGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLOOKUPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPGRIP *arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLOOKUPGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_propinfos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_propinfos);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->lookup_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->lookup_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->lookup_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->lookup_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->lookup_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->lookup_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->lookup_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->lookup_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_index_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_index_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->unknown_t);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->unknown_t = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->unknown_t = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->unknown_t);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKLOOKUPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKLOOKUPPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKLOOKUPPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKLOOKUPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKLOOKUPPARAMETER *arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKLOOKUPPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKLOOKUPPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKLOOKUPPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKMOVEACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [2]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)2; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [2]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_action_offset_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_x_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_x_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_action_offset_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_y_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_action_offset_y_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_angle_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKMOVEACTION_angle_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_angle_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKMOVEACTION_angle_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKMOVEACTION_angle_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKMOVEACTION_angle_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKMOVEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKMOVEACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKMOVEACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKMOVEACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKMOVEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKMOVEACTION *arg1 = (struct _dwg_object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKMOVEACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKMOVEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKMOVEACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKMOVEACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKMOVEACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_propinfos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_propinfos);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_position_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->position_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->position_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->position_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->position_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->position_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->position_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->position_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->position_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_label_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_label_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPOINTPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPOINTPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKPOINTPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOINTPARAMETER *arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPOINTPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOINTPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPOINTPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPOINTPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPOLARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPOLARGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPOLARGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKPOLARGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPOLARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARGRIP *arg1 = (struct _dwg_object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPOLARGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->angle_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->angle_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->angle_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->angle_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->angle_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->angle_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->angle_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->angle_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->distance_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->distance_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->distance_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->distance_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->distance_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->distance_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->distance_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->distance_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->angle_value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->angle_value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->distance_value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->distance_value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPOLARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPOLARPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPOLARPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKPOLARPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPOLARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARPARAMETER *arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPOLARPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [6]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_hdls);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->hdls);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BS *arg2 = (BITCODE_BS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set" "', argument " "2"" of type '" "BITCODE_BS *""'"); 
  }
  arg2 = (BITCODE_BS *)(argp2);
  if (arg1) (arg1)->shorts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BS *) ((arg1)->shorts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_codes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_codes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->codes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->codes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPOLARSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPOLARSTRETCHACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKPOLARSTRETCHACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPOLARSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPOLARSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPOLARSTRETCHACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPOLARSTRETCHACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARSTRETCHACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPOLARSTRETCHACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLE *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLE *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPROPERTIESTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPROPERTIESTABLE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPROPERTIESTABLE *)calloc(1, sizeof(struct _dwg_object_BLOCKPROPERTIESTABLE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPROPERTIESTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLE *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPROPERTIESTABLE" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLE *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPROPERTIESTABLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPROPERTIESTABLE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKPROPERTIESTABLEGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKPROPERTIESTABLEGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKPROPERTIESTABLEGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKPROPERTIESTABLEGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKPROPERTIESTABLEGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKREPRESENTATION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKREPRESENTATION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKREPRESENTATION_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_flag_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKREPRESENTATION_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_flag_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKREPRESENTATION_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_block_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKREPRESENTATION_block_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKREPRESENTATION_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKREPRESENTATION_block_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  result = (BITCODE_H) ((arg1)->block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKREPRESENTATION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKREPRESENTATION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKREPRESENTATION *)calloc(1, sizeof(struct _dwg_object_BLOCKREPRESENTATION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKREPRESENTATION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKREPRESENTATION *arg1 = (struct _dwg_object_BLOCKREPRESENTATION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKREPRESENTATION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKREPRESENTATION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKREPRESENTATION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKREPRESENTATION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKREPRESENTATION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_offset_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [3]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_dependent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_dependent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_dependent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATEACTION_dependent_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dependent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_dependent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_dependent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_B) ((arg1)->dependent);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATEACTION_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_base_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATEACTION_base_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATEACTION_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATEACTION_base_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKROTATEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKROTATEACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKROTATEACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKROTATEACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKROTATEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATEACTION *arg1 = (struct _dwg_object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKROTATEACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATEACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKROTATEACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKROTATEACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKROTATIONGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKROTATIONGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKROTATIONGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKROTATIONGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKROTATIONGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONGRIP *arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKROTATIONGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKROTATIONGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKROTATIONGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_base_angle_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_base_angle_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->angle_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->angle_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->angle_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->angle_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->angle_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->angle_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->angle_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->angle_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->angle_value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->angle_value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKROTATIONPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKROTATIONPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKROTATIONPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKROTATIONPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKROTATIONPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKROTATIONPARAMETER *arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKROTATIONPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKROTATIONPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKROTATIONPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKROTATIONPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_offset_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [5]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)5; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [5]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_dependent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_dependent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_dependent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSCALEACTION_dependent_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->dependent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_dependent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_dependent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_B) ((arg1)->dependent);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_base_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSCALEACTION_base_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_base_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSCALEACTION_base_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->base_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSCALEACTION_base_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSCALEACTION_base_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->base_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKSCALEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKSCALEACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKSCALEACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKSCALEACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKSCALEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSCALEACTION *arg1 = (struct _dwg_object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKSCALEACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSCALEACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSCALEACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKSCALEACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKSCALEACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  struct _dwg_object_BLOCKSTRETCHACTION *arg2 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_handles_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_parent_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_parent_set" "', argument " "2"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg2 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_BLOCKSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_parent_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  result = (struct _dwg_object_BLOCKSTRETCHACTION *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_handles_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_hdl_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_hdl_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->hdl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_hdl_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  result = (BITCODE_H) ((arg1)->hdl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_indexes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_num_indexes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_indexes);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_indexes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_handles_indexes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_indexes_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_indexes_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->indexes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_handles_indexes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_handles_indexes_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  result = (BITCODE_BL *) ((arg1)->indexes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKSTRETCHACTION_handles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKSTRETCHACTION_handles", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKSTRETCHACTION_handles *)calloc(1, sizeof(struct _dwg_BLOCKSTRETCHACTION_handles));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKSTRETCHACTION_handles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_handles *arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKSTRETCHACTION_handles" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_handles *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKSTRETCHACTION_handles_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKSTRETCHACTION_handles_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  struct _dwg_object_BLOCKSTRETCHACTION *arg2 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_codes_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_parent_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_parent_set" "', argument " "2"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg2 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_BLOCKSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_parent_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  result = (struct _dwg_object_BLOCKSTRETCHACTION *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_bl95_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_codes_bl95_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_bl95_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_bl95_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bl95 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_bl95_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_bl95_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  result = (BITCODE_BL) ((arg1)->bl95);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_indexes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_num_indexes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_indexes);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_indexes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_BLOCKSTRETCHACTION_codes_indexes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_indexes_set" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_indexes_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->indexes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_BLOCKSTRETCHACTION_codes_indexes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_BLOCKSTRETCHACTION_codes_indexes_get" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  result = (BITCODE_BL *) ((arg1)->indexes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_BLOCKSTRETCHACTION_codes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_BLOCKSTRETCHACTION_codes", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_BLOCKSTRETCHACTION_codes *)calloc(1, sizeof(struct _dwg_BLOCKSTRETCHACTION_codes));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_BLOCKSTRETCHACTION_codes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_BLOCKSTRETCHACTION_codes *arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_BLOCKSTRETCHACTION_codes" "', argument " "1"" of type '" "struct _dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg1 = (struct _dwg_BLOCKSTRETCHACTION_codes *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_BLOCKSTRETCHACTION_codes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_BLOCKSTRETCHACTION_codes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_display_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_display_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_display_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_display_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->display_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_display_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_display_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->display_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_num_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_actions_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_actions);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_actions_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL *) ((arg1)->actions);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_num_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_deps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_deps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_deps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_deps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_deps_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_deps_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->deps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_deps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_deps_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_H *) ((arg1)->deps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  Dwg_BLOCKACTION_connectionpts *arg2 = (Dwg_BLOCKACTION_connectionpts *) (Dwg_BLOCKACTION_connectionpts *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set" "', argument " "2"" of type '" "Dwg_BLOCKACTION_connectionpts [2]""'"); 
  } 
  arg2 = (Dwg_BLOCKACTION_connectionpts *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)2; ++ii) *(Dwg_BLOCKACTION_connectionpts *)&arg1->conn_pts[ii] = *((Dwg_BLOCKACTION_connectionpts *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""conn_pts""' of type '""Dwg_BLOCKACTION_connectionpts [2]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_conn_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKACTION_connectionpts *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (Dwg_BLOCKACTION_connectionpts *)(Dwg_BLOCKACTION_connectionpts *) ((arg1)->conn_pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKACTION_connectionpts, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_num_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_pts_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_pts_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_pts_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_hdls);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_hdls_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  Dwg_BLOCKSTRETCHACTION_handles *arg2 = (Dwg_BLOCKSTRETCHACTION_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_hdls_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_hdls_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_hdls_set" "', argument " "2"" of type '" "Dwg_BLOCKSTRETCHACTION_handles *""'"); 
  }
  arg2 = (Dwg_BLOCKSTRETCHACTION_handles *)(argp2);
  if (arg1) (arg1)->hdls = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_hdls_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKSTRETCHACTION_handles *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_hdls_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (Dwg_BLOCKSTRETCHACTION_handles *) ((arg1)->hdls);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_handles, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_codes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_num_codes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_codes_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_codes_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_codes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_num_codes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_num_codes_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_codes);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_codes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  Dwg_BLOCKSTRETCHACTION_codes *arg2 = (Dwg_BLOCKSTRETCHACTION_codes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_codes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_codes_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_codes_set" "', argument " "2"" of type '" "Dwg_BLOCKSTRETCHACTION_codes *""'"); 
  }
  arg2 = (Dwg_BLOCKSTRETCHACTION_codes *)(argp2);
  if (arg1) (arg1)->codes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_codes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKSTRETCHACTION_codes *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_codes_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (Dwg_BLOCKSTRETCHACTION_codes *) ((arg1)->codes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKSTRETCHACTION_codes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_x);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->action_offset_y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->action_offset_y);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->angle_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKSTRETCHACTION_angle_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  result = (BITCODE_BD) ((arg1)->angle_offset);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKSTRETCHACTION", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKSTRETCHACTION *)calloc(1, sizeof(struct _dwg_object_BLOCKSTRETCHACTION));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKSTRETCHACTION *arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKSTRETCHACTION" "', argument " "1"" of type '" "struct _dwg_object_BLOCKSTRETCHACTION *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKSTRETCHACTION *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKSTRETCHACTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKSTRETCHACTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_def_pt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_def_pt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_def_pt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_def_pt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_pt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_def_pt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_def_pt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_pt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_propinfos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_propinfos);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_flag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_flag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_flag_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_flag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->flag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_flag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_flag_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->flag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->assocvariable = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_assocvariable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_H) ((arg1)->assocvariable);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_expr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_expr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_expr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_expr_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->expr);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->expr = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->expr = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_expr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_expr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->expr);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  Dwg_EvalVariant *arg2 = (Dwg_EvalVariant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_value_set" "', argument " "2"" of type '" "Dwg_EvalVariant *""'"); 
  }
  arg2 = (Dwg_EvalVariant *)(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalVariant *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (Dwg_EvalVariant *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalVariant, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKUSERPARAMETER_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_type_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKUSERPARAMETER_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKUSERPARAMETER_type_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKUSERPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKUSERPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKUSERPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKUSERPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKUSERPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKUSERPARAMETER *arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKUSERPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKUSERPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKUSERPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKUSERPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKUSERPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYGRIP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYGRIP_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYGRIP_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_bl91_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_bg_bl91_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl91_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl91_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl91 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_bl91_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl91_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl91);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_bl92_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_bg_bl92_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl92_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl92_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->bg_bl92 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_bl92_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_bl92_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BL) ((arg1)->bg_bl92);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_bg_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_location_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->bg_location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->bg_location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->bg_insert_cycling = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_B) ((arg1)->bg_insert_cycling);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  BITCODE_BLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set" "', argument " "2"" of type '" "BITCODE_BLd""'");
  } 
  arg2 = (BITCODE_BLd)(val2);
  if (arg1) (arg1)->bg_insert_cycling_weight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  result = (BITCODE_BLd) ((arg1)->bg_insert_cycling_weight);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKXYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKXYGRIP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKXYGRIP *)calloc(1, sizeof(struct _dwg_object_BLOCKXYGRIP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYGRIP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKXYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYGRIP *arg1 = (struct _dwg_object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKXYGRIP" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYGRIP *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYGRIP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKXYGRIP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKXYGRIP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKXYGRIP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parent_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parent_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_name_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_name_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_be_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_be_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_major_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_major_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_be_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_major_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_major);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_be_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_be_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_minor_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_minor_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->be_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_be_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_be_minor_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->be_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_eed1071_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_eed1071_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_eed1071_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_eed1071_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->eed1071 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_eed1071_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_eed1071_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BL) ((arg1)->eed1071);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_show_properties_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_show_properties_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_show_properties_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_show_properties_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_properties = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_show_properties_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_show_properties_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->show_properties);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_chain_actions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_chain_actions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_chain_actions_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_chain_actions_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->chain_actions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_chain_actions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_chain_actions_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_B) ((arg1)->chain_actions);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_def_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_def_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_def_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_def_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_def_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->def_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_def_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_def_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->def_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_prop1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop1_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop1_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop1_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_prop2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop2_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop2_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop2_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_prop3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop3_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop3_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop3_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMETER_PropInfo *arg2 = (Dwg_BLOCKPARAMETER_PropInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_prop4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop4_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop4_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMETER_PropInfo *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMETER_PropInfo *)(argp2);
  if (arg1) (arg1)->prop4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMETER_PropInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop4_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMETER_PropInfo *)& ((arg1)->prop4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMETER_PropInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BL *arg2 = (BITCODE_BL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_prop_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop_states_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop_states_set" "', argument " "2"" of type '" "BITCODE_BL *""'"); 
  }
  arg2 = (BITCODE_BL *)(argp2);
  if (arg1) (arg1)->prop_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_prop_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_prop_states_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BL *) ((arg1)->prop_states);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->parameter_base_location = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BS) ((arg1)->parameter_base_location);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_upd_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_upd_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_upd_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_basept_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_basept_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_basept_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_basept_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->basept = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_basept_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_basept_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->basept);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->upd_endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_upd_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->upd_endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_endpt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_endpt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_endpt_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_endpt_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->endpt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_endpt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_endpt_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->endpt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_x_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->x_label);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->x_label = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->x_label = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->x_label);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->x_label_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->x_label_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->x_label_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->x_label_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_y_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->y_label);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->y_label = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->y_label = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->y_label);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->y_label_desc);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->y_label_desc = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->y_label_desc = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_TV) ((arg1)->y_label_desc);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_x_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->x_value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->x_value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_y_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->y_value = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (BITCODE_BD) ((arg1)->y_value);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_x_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->x_value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_x_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->x_value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  Dwg_BLOCKPARAMVALUESET *arg2 = (Dwg_BLOCKPARAMVALUESET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_BLOCKXYPARAMETER_y_value_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_set_set" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_set_set" "', argument " "2"" of type '" "Dwg_BLOCKPARAMVALUESET *""'"); 
  }
  arg2 = (Dwg_BLOCKPARAMVALUESET *)(argp2);
  if (arg1) (arg1)->y_value_set = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_BLOCKPARAMVALUESET *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_BLOCKXYPARAMETER_y_value_set_get" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  result = (Dwg_BLOCKPARAMVALUESET *)& ((arg1)->y_value_set);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_BLOCKPARAMVALUESET, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_BLOCKXYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_BLOCKXYPARAMETER", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_BLOCKXYPARAMETER *)calloc(1, sizeof(struct _dwg_object_BLOCKXYPARAMETER));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_BLOCKXYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_BLOCKXYPARAMETER *arg1 = (struct _dwg_object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_BLOCKXYPARAMETER" "', argument " "1"" of type '" "struct _dwg_object_BLOCKXYPARAMETER *""'"); 
  }
  arg1 = (struct _dwg_object_BLOCKXYPARAMETER *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_BLOCKXYPARAMETER_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_BLOCKXYPARAMETER_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_get" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *) 0 ;
  Dwg_EvalExpr *arg2 = (Dwg_EvalExpr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set" "', argument " "2"" of type '" "Dwg_EvalExpr *""'"); 
  }
  arg2 = (Dwg_EvalExpr *)(argp2);
  if (arg1) (arg1)->evalexpr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_EvalExpr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_get" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)(argp1);
  result = (Dwg_EvalExpr *)& ((arg1)->evalexpr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_EvalExpr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_DYNAMICBLOCKPROXYNODE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_DYNAMICBLOCKPROXYNODE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)calloc(1, sizeof(struct _dwg_object_DYNAMICBLOCKPROXYNODE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_DYNAMICBLOCKPROXYNODE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_DYNAMICBLOCKPROXYNODE *arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_DYNAMICBLOCKPROXYNODE" "', argument " "1"" of type '" "struct _dwg_object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg1 = (struct _dwg_object_DYNAMICBLOCKPROXYNODE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_DYNAMICBLOCKPROXYNODE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_DYNAMICBLOCKPROXYNODE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  struct _dwg_entity_POINTCLOUD *arg2 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_IntensityStyle_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_parent_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUD_IntensityStyle_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg2 = (struct _dwg_entity_POINTCLOUD *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_POINTCLOUD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_parent_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  result = (struct _dwg_entity_POINTCLOUD *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_min_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_IntensityStyle_min_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_min_intensity_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_IntensityStyle_min_intensity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->min_intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_min_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_min_intensity_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->min_intensity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_max_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_IntensityStyle_max_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_max_intensity_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_IntensityStyle_max_intensity_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->max_intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_max_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_max_intensity_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->max_intensity);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->intensity_low_treshold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->intensity_low_treshold);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->intensity_high_treshold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  result = (BITCODE_BD) ((arg1)->intensity_high_treshold);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_POINTCLOUD_IntensityStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_POINTCLOUD_IntensityStyle", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_POINTCLOUD_IntensityStyle *)calloc(1, sizeof(struct _dwg_POINTCLOUD_IntensityStyle));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_POINTCLOUD_IntensityStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_IntensityStyle *arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_POINTCLOUD_IntensityStyle" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_IntensityStyle *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_POINTCLOUD_IntensityStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_POINTCLOUD_IntensityStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  struct _dwg_entity_POINTCLOUD *arg2 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_parent_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUD_Clippings_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg2 = (struct _dwg_entity_POINTCLOUD *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_POINTCLOUD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_parent_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (struct _dwg_entity_POINTCLOUD *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_is_inverted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_is_inverted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_is_inverted_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_Clippings_is_inverted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_inverted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_is_inverted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_is_inverted_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_B) ((arg1)->is_inverted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_type_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_Clippings_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_type_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_num_vertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_num_vertices_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_num_vertices_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_Clippings_num_vertices_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_vertices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_num_vertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_num_vertices_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_vertices);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_vertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_2RD *arg2 = (BITCODE_2RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_vertices_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_vertices_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_2rd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUD_Clippings_vertices_set" "', argument " "2"" of type '" "BITCODE_2RD *""'"); 
  }
  arg2 = (BITCODE_2RD *)(argp2);
  if (arg1) (arg1)->vertices = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_vertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_2RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_vertices_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_2RD *) ((arg1)->vertices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_2rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_z_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_z_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_z_min_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_Clippings_z_min_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->z_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_z_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_z_min_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_BD) ((arg1)->z_min);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_z_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUD_Clippings_z_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_z_max_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUD_Clippings_z_max_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->z_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUD_Clippings_z_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUD_Clippings_z_max_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  result = (BITCODE_BD) ((arg1)->z_max);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_POINTCLOUD_Clippings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_POINTCLOUD_Clippings", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_POINTCLOUD_Clippings *)calloc(1, sizeof(struct _dwg_POINTCLOUD_Clippings));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUD_Clippings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_POINTCLOUD_Clippings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUD_Clippings *arg1 = (struct _dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_POINTCLOUD_Clippings" "', argument " "1"" of type '" "struct _dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUD_Clippings *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_POINTCLOUD_Clippings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_POINTCLOUD_Clippings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_POINTCLOUD_Clippings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  struct _dwg_entity_POINTCLOUDEX *arg2 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_parent_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDEX_Croppings_parent_set" "', argument " "2"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg2 = (struct _dwg_entity_POINTCLOUDEX *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_entity_POINTCLOUDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_parent_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (struct _dwg_entity_POINTCLOUDEX *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_type_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDEX_Croppings_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_type_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_is_inside_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_is_inside_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inside_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inside_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_inside = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_is_inside_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inside_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_B) ((arg1)->is_inside);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_is_inverted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_is_inverted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inverted_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inverted_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_inverted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_is_inverted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_is_inverted_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_B) ((arg1)->is_inverted);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_plane_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_crop_plane_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_plane_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_plane_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->crop_plane = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_plane_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_plane_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->crop_plane);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->crop_x_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_x_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->crop_x_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->crop_y_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_crop_y_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->crop_y_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_num_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_num_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_num_pts_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDEX_Croppings_num_pts_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_num_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_num_pts_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_pts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_pts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDEX_Croppings_pts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_pts_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDEX_Croppings_pts_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->pts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDEX_Croppings_pts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDEX_Croppings_pts_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  result = (BITCODE_3BD *) ((arg1)->pts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_POINTCLOUDEX_Croppings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_POINTCLOUDEX_Croppings", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_POINTCLOUDEX_Croppings *)calloc(1, sizeof(struct _dwg_POINTCLOUDEX_Croppings));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_POINTCLOUDEX_Croppings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDEX_Croppings *arg1 = (struct _dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_POINTCLOUDEX_Croppings" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDEX_Croppings *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_POINTCLOUDEX_Croppings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_POINTCLOUDEX_Croppings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_origin_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_origin_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_origin_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_saved_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_saved_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_saved_filename_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_saved_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->saved_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->saved_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->saved_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_saved_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_saved_filename_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_TV) ((arg1)->saved_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_num_source_files_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_num_source_files_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_num_source_files_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_num_source_files_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_source_files = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_num_source_files_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_num_source_files_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_source_files);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_source_files_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_source_files_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_source_files_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_source_files_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->source_files = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_source_files_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_source_files_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_TV *) ((arg1)->source_files);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_extents_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_extents_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_extents_min_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_extents_min_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_extents_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_extents_min_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_extents_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_extents_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_extents_max_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_extents_max_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_extents_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_extents_max_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_numpoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_numpoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_numpoints_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_numpoints_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->numpoints = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_numpoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_numpoints_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_RLL) ((arg1)->numpoints);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_ucs_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_name_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_ucs_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->ucs_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->ucs_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->ucs_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_name_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_TV) ((arg1)->ucs_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_ucs_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_origin_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_ucs_origin_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_origin_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_x_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_ucs_x_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_x_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_ucs_x_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_x_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_x_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_x_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_x_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_y_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_ucs_y_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_y_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_ucs_y_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_y_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_y_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_y_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_y_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_z_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_ucs_z_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_z_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_ucs_z_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_z_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_ucs_z_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_ucs_z_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_z_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_pointclouddef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_pointclouddef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_pointclouddef_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_pointclouddef_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->pointclouddef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_pointclouddef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_pointclouddef_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_H) ((arg1)->pointclouddef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_reactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_reactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_reactor_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_reactor_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->reactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_reactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_reactor_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_H) ((arg1)->reactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_show_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_show_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_show_intensity_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_show_intensity_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_show_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_show_intensity_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_B) ((arg1)->show_intensity);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_intensity_scheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_intensity_scheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_intensity_scheme_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_intensity_scheme_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->intensity_scheme = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_intensity_scheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_intensity_scheme_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_BS) ((arg1)->intensity_scheme);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_intensity_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  Dwg_POINTCLOUD_IntensityStyle *arg2 = (Dwg_POINTCLOUD_IntensityStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_intensity_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_intensity_style_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_intensity_style_set" "', argument " "2"" of type '" "Dwg_POINTCLOUD_IntensityStyle *""'"); 
  }
  arg2 = (Dwg_POINTCLOUD_IntensityStyle *)(argp2);
  if (arg1) (arg1)->intensity_style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_intensity_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_POINTCLOUD_IntensityStyle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_intensity_style_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (Dwg_POINTCLOUD_IntensityStyle *)& ((arg1)->intensity_style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUD_IntensityStyle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_show_clipping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_show_clipping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_show_clipping_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_show_clipping_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_clipping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_show_clipping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_show_clipping_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_B) ((arg1)->show_clipping);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_num_clippings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_num_clippings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_num_clippings_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUD_num_clippings_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_clippings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_num_clippings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_num_clippings_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_clippings);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_clippings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  Dwg_POINTCLOUD_Clippings *arg2 = (Dwg_POINTCLOUD_Clippings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUD_clippings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_clippings_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUD_Clippings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUD_clippings_set" "', argument " "2"" of type '" "Dwg_POINTCLOUD_Clippings *""'"); 
  }
  arg2 = (Dwg_POINTCLOUD_Clippings *)(argp2);
  if (arg1) (arg1)->clippings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUD_clippings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_POINTCLOUD_Clippings *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUD_clippings_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  result = (Dwg_POINTCLOUD_Clippings *) ((arg1)->clippings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUD_Clippings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POINTCLOUD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POINTCLOUD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POINTCLOUD *)calloc(1, sizeof(struct _dwg_entity_POINTCLOUD));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POINTCLOUD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUD *arg1 = (struct _dwg_entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POINTCLOUD" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUD *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUD *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POINTCLOUD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POINTCLOUD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_class_version_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_class_version_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_extents_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_extents_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_min_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_min_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_extents_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_min_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_extents_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_extents_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_max_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_max_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_extents_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_extents_max_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_ucs_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_origin_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_origin_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_origin_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_x_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_x_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_x_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_y_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_y_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_y_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->ucs_z_dir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_ucs_z_dir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->ucs_z_dir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_is_locked_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_is_locked_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_is_locked_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_is_locked_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_locked = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_is_locked_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_is_locked_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->is_locked);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_pointclouddefex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_pointclouddefex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_pointclouddefex_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_pointclouddefex_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->pointclouddefex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_pointclouddefex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_pointclouddefex_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_H) ((arg1)->pointclouddefex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_reactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_reactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_reactor_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_reactor_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->reactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_reactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_reactor_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_H) ((arg1)->reactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_name_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_name_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_show_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_show_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_show_intensity_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_show_intensity_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_intensity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_show_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_show_intensity_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->show_intensity);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_stylization_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_stylization_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_stylization_type_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_stylization_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->stylization_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_stylization_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_stylization_type_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BS) ((arg1)->stylization_type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->intensity_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->intensity_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->intensity_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_TV) ((arg1)->intensity_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->cur_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->cur_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->cur_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_cur_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_TV) ((arg1)->cur_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->classification_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->classification_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->classification_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_classification_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_TV) ((arg1)->classification_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_elevation_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_min_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_min_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_min_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation_min);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_elevation_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_max_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_max_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->elevation_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_max_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BD) ((arg1)->elevation_max);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_intensity_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_min_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_min_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->intensity_min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_min_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->intensity_min);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_intensity_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_max_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_max_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->intensity_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_max_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->intensity_max);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->intensity_out_of_range_behavior = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BS) ((arg1)->intensity_out_of_range_behavior);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->elevation_out_of_range_behavior = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BS) ((arg1)->elevation_out_of_range_behavior);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->elevation_apply_to_fixed_range = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->elevation_apply_to_fixed_range);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->intensity_as_gradient = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->intensity_as_gradient);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->elevation_as_gradient = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->elevation_as_gradient);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_show_cropping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_show_cropping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_show_cropping_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_show_cropping_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->show_cropping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_show_cropping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_show_cropping_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->show_cropping);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_unknown_bl0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl0_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl0_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl0_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl0);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_unknown_bl1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl1_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_unknown_bl1_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_num_croppings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_num_croppings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_num_croppings_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_POINTCLOUDEX_num_croppings_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_croppings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_num_croppings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_num_croppings_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_croppings);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_croppings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  Dwg_POINTCLOUDEX_Croppings *arg2 = (Dwg_POINTCLOUDEX_Croppings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_POINTCLOUDEX_croppings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_croppings_set" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_POINTCLOUDEX_croppings_set" "', argument " "2"" of type '" "Dwg_POINTCLOUDEX_Croppings *""'"); 
  }
  arg2 = (Dwg_POINTCLOUDEX_Croppings *)(argp2);
  if (arg1) (arg1)->croppings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_POINTCLOUDEX_croppings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_POINTCLOUDEX_Croppings *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_POINTCLOUDEX_croppings_get" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  result = (Dwg_POINTCLOUDEX_Croppings *) ((arg1)->croppings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDEX_Croppings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_POINTCLOUDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_POINTCLOUDEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_POINTCLOUDEX *)calloc(1, sizeof(struct _dwg_entity_POINTCLOUDEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUDEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_POINTCLOUDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_POINTCLOUDEX *arg1 = (struct _dwg_entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_POINTCLOUDEX" "', argument " "1"" of type '" "struct _dwg_entity_POINTCLOUDEX *""'"); 
  }
  arg1 = (struct _dwg_entity_POINTCLOUDEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_POINTCLOUDEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_POINTCLOUDEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_POINTCLOUDEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEF_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_source_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_source_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_source_filename_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_source_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->source_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->source_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->source_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_source_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_source_filename_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_TV) ((arg1)->source_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_is_loaded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_is_loaded_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_is_loaded_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEF_is_loaded_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_loaded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_is_loaded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_is_loaded_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_B) ((arg1)->is_loaded);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_numpoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_numpoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_numpoints_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEF_numpoints_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->numpoints = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_numpoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_numpoints_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_RLL) ((arg1)->numpoints);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_extents_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_extents_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_min_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_min_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_extents_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_min_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_extents_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_extents_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_max_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_max_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_extents_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_extents_max_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTCLOUDDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTCLOUDDEF", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTCLOUDDEF *)calloc(1, sizeof(struct _dwg_object_POINTCLOUDDEF));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTCLOUDDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF *arg1 = (struct _dwg_object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTCLOUDDEF" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTCLOUDDEF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_source_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_source_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_source_filename_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_source_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->source_filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->source_filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->source_filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_source_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_source_filename_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_TV) ((arg1)->source_filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_is_loaded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_is_loaded_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_is_loaded_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_is_loaded_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_loaded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_is_loaded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_is_loaded_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_B) ((arg1)->is_loaded);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_numpoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_numpoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_numpoints_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_numpoints_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->numpoints = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_numpoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_numpoints_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_RLL) ((arg1)->numpoints);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_extents_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_extents_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_min_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_min_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_extents_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_min_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_extents_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEFEX_extents_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_max_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_max_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEFEX_extents_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEFEX_extents_max_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTCLOUDDEFEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTCLOUDDEFEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTCLOUDDEFEX *)calloc(1, sizeof(struct _dwg_object_POINTCLOUDDEFEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTCLOUDDEFEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEFEX *arg1 = (struct _dwg_object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTCLOUDDEFEX" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEFEX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEFEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEFEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEFEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTCLOUDDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTCLOUDDEF_REACTOR", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)calloc(1, sizeof(struct _dwg_object_POINTCLOUDDEF_REACTOR));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTCLOUDDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTCLOUDDEF_REACTOR" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_REACTOR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_REACTOR_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)(argp1);
  result = (BITCODE_BL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTCLOUDDEF_REACTOR_EX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTCLOUDDEF_REACTOR_EX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)calloc(1, sizeof(struct _dwg_object_POINTCLOUDDEF_REACTOR_EX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTCLOUDDEF_REACTOR_EX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTCLOUDDEF_REACTOR_EX" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg2 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ColorRamp_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_parent_set" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ColorRamp_parent_set" "', argument " "2"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg2 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_parent_get" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  result = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ColorRamp_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ColorRamp_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  result = (BITCODE_TV) ((arg1)->colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_unknown_bl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ColorRamp_unknown_bl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_unknown_bl_set" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ColorRamp_unknown_bl_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_bl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_unknown_bl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_unknown_bl_get" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_bl);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_unknown_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ColorRamp_unknown_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_unknown_b_set" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ColorRamp_unknown_b_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->unknown_b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ColorRamp_unknown_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ColorRamp_unknown_b_get" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  result = (BITCODE_B) ((arg1)->unknown_b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ColorRamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ColorRamp", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_ColorRamp *)calloc(1, sizeof(struct _dwg_ColorRamp));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ColorRamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ColorRamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_ColorRamp *arg1 = (struct _dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_ColorRamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ColorRamp" "', argument " "1"" of type '" "struct _dwg_ColorRamp *""'"); 
  }
  arg1 = (struct _dwg_ColorRamp *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ColorRamp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_ColorRamp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ColorRamp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg2 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set" "', argument " "2"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg2 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_POINTCLOUDCOLORMAP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  result = (struct _dwg_object_POINTCLOUDCOLORMAP *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_ramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_ramps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  Dwg_ColorRamp *arg2 = (Dwg_ColorRamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_ColorRamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set" "', argument " "2"" of type '" "Dwg_ColorRamp *""'"); 
  }
  arg2 = (Dwg_ColorRamp *)(argp2);
  if (arg1) (arg1)->ramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ColorRamp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_get" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  result = (Dwg_ColorRamp *) ((arg1)->ramps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_ColorRamp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_POINTCLOUDCOLORMAP_Ramp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_POINTCLOUDCOLORMAP_Ramp", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)calloc(1, sizeof(struct _dwg_POINTCLOUDCOLORMAP_Ramp));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_POINTCLOUDCOLORMAP_Ramp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_POINTCLOUDCOLORMAP_Ramp *arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_POINTCLOUDCOLORMAP_Ramp" "', argument " "1"" of type '" "struct _dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg1 = (struct _dwg_POINTCLOUDCOLORMAP_Ramp *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_POINTCLOUDCOLORMAP_Ramp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_POINTCLOUDCOLORMAP_Ramp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_parent_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_parent_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_class_version_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_class_version_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_class_version_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_BS) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->def_intensity_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->def_intensity_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->def_intensity_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_TV) ((arg1)->def_intensity_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->def_elevation_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->def_elevation_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->def_elevation_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_TV) ((arg1)->def_elevation_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->def_classification_colorscheme);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->def_classification_colorscheme = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->def_classification_colorscheme = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_TV) ((arg1)->def_classification_colorscheme);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_colorramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_colorramps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  Dwg_POINTCLOUDCOLORMAP_Ramp *arg2 = (Dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set" "', argument " "2"" of type '" "Dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg2 = (Dwg_POINTCLOUDCOLORMAP_Ramp *)(argp2);
  if (arg1) (arg1)->colorramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_colorramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_POINTCLOUDCOLORMAP_Ramp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (Dwg_POINTCLOUDCOLORMAP_Ramp *) ((arg1)->colorramps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_classification_colorramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_classification_colorramps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  Dwg_POINTCLOUDCOLORMAP_Ramp *arg2 = (Dwg_POINTCLOUDCOLORMAP_Ramp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set" "', argument " "2"" of type '" "Dwg_POINTCLOUDCOLORMAP_Ramp *""'"); 
  }
  arg2 = (Dwg_POINTCLOUDCOLORMAP_Ramp *)(argp2);
  if (arg1) (arg1)->classification_colorramps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_POINTCLOUDCOLORMAP_Ramp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_get" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  result = (Dwg_POINTCLOUDCOLORMAP_Ramp *) ((arg1)->classification_colorramps);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_POINTCLOUDCOLORMAP_Ramp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_POINTCLOUDCOLORMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_POINTCLOUDCOLORMAP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_POINTCLOUDCOLORMAP *)calloc(1, sizeof(struct _dwg_object_POINTCLOUDCOLORMAP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_POINTCLOUDCOLORMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_POINTCLOUDCOLORMAP *arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_POINTCLOUDCOLORMAP" "', argument " "1"" of type '" "struct _dwg_object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg1 = (struct _dwg_object_POINTCLOUDCOLORMAP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_POINTCLOUDCOLORMAP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_POINTCLOUDCOLORMAP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_COMPOUNDOBJECTID_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_parent_set" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_COMPOUNDOBJECTID_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_parent_get" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_has_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_COMPOUNDOBJECTID_has_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_has_object_set" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_COMPOUNDOBJECTID_has_object_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_has_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_has_object_get" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  result = (BITCODE_B) ((arg1)->has_object);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_COMPOUNDOBJECTID_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_name_set" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_COMPOUNDOBJECTID_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_name_get" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  result = (BITCODE_TV) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_COMPOUNDOBJECTID_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_object_set" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_COMPOUNDOBJECTID_object_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_COMPOUNDOBJECTID_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_COMPOUNDOBJECTID_object_get" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  result = (BITCODE_H) ((arg1)->object);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_COMPOUNDOBJECTID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_COMPOUNDOBJECTID", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_COMPOUNDOBJECTID *)calloc(1, sizeof(struct _dwg_COMPOUNDOBJECTID));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_COMPOUNDOBJECTID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_COMPOUNDOBJECTID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_COMPOUNDOBJECTID *arg1 = (struct _dwg_COMPOUNDOBJECTID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_COMPOUNDOBJECTID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_COMPOUNDOBJECTID" "', argument " "1"" of type '" "struct _dwg_COMPOUNDOBJECTID *""'"); 
  }
  arg1 = (struct _dwg_COMPOUNDOBJECTID *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_COMPOUNDOBJECTID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_COMPOUNDOBJECTID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_COMPOUNDOBJECTID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg2 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set" "', argument " "2"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg2 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_get" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  result = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_get" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  BITCODE_3BD *arg2 = (BITCODE_3BD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set" "', argument " "2"" of type '" "BITCODE_3BD *""'"); 
  }
  arg2 = (BITCODE_3BD *)(argp2);
  if (arg1) (arg1)->extents_max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3BD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_get" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  result = (BITCODE_3BD *)& ((arg1)->extents_max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3bd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_get" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  result = (BITCODE_H) ((arg1)->object);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_PARTIAL_VIEWING_INDEX_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_PARTIAL_VIEWING_INDEX_Entry", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)calloc(1, sizeof(struct _dwg_PARTIAL_VIEWING_INDEX_Entry));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_PARTIAL_VIEWING_INDEX_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_PARTIAL_VIEWING_INDEX_Entry *arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_PARTIAL_VIEWING_INDEX_Entry" "', argument " "1"" of type '" "struct _dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg1 = (struct _dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_PARTIAL_VIEWING_INDEX_Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_PARTIAL_VIEWING_INDEX_Entry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_get" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_get" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_get" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  result = (BITCODE_B) ((arg1)->has_entries);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  Dwg_PARTIAL_VIEWING_INDEX_Entry *arg2 = (Dwg_PARTIAL_VIEWING_INDEX_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set" "', argument " "2"" of type '" "Dwg_PARTIAL_VIEWING_INDEX_Entry *""'"); 
  }
  arg2 = (Dwg_PARTIAL_VIEWING_INDEX_Entry *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_PARTIAL_VIEWING_INDEX_Entry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_get" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  result = (Dwg_PARTIAL_VIEWING_INDEX_Entry *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_PARTIAL_VIEWING_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_PARTIAL_VIEWING_INDEX", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)calloc(1, sizeof(struct _dwg_object_PARTIAL_VIEWING_INDEX));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_PARTIAL_VIEWING_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_PARTIAL_VIEWING_INDEX *arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_PARTIAL_VIEWING_INDEX" "', argument " "1"" of type '" "struct _dwg_object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg1 = (struct _dwg_object_PARTIAL_VIEWING_INDEX *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_PARTIAL_VIEWING_INDEX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_PARTIAL_VIEWING_INDEX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_UNKNOWN_ENT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_UNKNOWN_ENT *arg1 = (struct _dwg_entity_UNKNOWN_ENT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_UNKNOWN_ENT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNKNOWN_ENT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_UNKNOWN_ENT *""'"); 
  }
  arg1 = (struct _dwg_entity_UNKNOWN_ENT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_UNKNOWN_ENT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_UNKNOWN_ENT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_UNKNOWN_ENT *arg1 = (struct _dwg_entity_UNKNOWN_ENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_UNKNOWN_ENT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_UNKNOWN_ENT *""'"); 
  }
  arg1 = (struct _dwg_entity_UNKNOWN_ENT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_UNKNOWN_ENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_UNKNOWN_ENT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_UNKNOWN_ENT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_UNKNOWN_ENT *)calloc(1, sizeof(struct _dwg_entity_UNKNOWN_ENT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_UNKNOWN_ENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_UNKNOWN_ENT *arg1 = (struct _dwg_entity_UNKNOWN_ENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_UNKNOWN_ENT" "', argument " "1"" of type '" "struct _dwg_entity_UNKNOWN_ENT *""'"); 
  }
  arg1 = (struct _dwg_entity_UNKNOWN_ENT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_UNKNOWN_ENT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_UNKNOWN_ENT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_UNKNOWN_OBJ_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UNKNOWN_OBJ *arg1 = (struct _dwg_object_UNKNOWN_OBJ *) 0 ;
  struct _dwg_object_object *arg2 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_UNKNOWN_OBJ_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNKNOWN_OBJ_parent_set" "', argument " "1"" of type '" "struct _dwg_object_UNKNOWN_OBJ *""'"); 
  }
  arg1 = (struct _dwg_object_UNKNOWN_OBJ *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_UNKNOWN_OBJ_parent_set" "', argument " "2"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg2 = (struct _dwg_object_object *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_UNKNOWN_OBJ_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UNKNOWN_OBJ *arg1 = (struct _dwg_object_UNKNOWN_OBJ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_UNKNOWN_OBJ_parent_get" "', argument " "1"" of type '" "struct _dwg_object_UNKNOWN_OBJ *""'"); 
  }
  arg1 = (struct _dwg_object_UNKNOWN_OBJ *)(argp1);
  result = (struct _dwg_object_object *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_UNKNOWN_OBJ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UNKNOWN_OBJ *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_UNKNOWN_OBJ", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_UNKNOWN_OBJ *)calloc(1, sizeof(struct _dwg_object_UNKNOWN_OBJ));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_UNKNOWN_OBJ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_UNKNOWN_OBJ *arg1 = (struct _dwg_object_UNKNOWN_OBJ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_UNKNOWN_OBJ" "', argument " "1"" of type '" "struct _dwg_object_UNKNOWN_OBJ *""'"); 
  }
  arg1 = (struct _dwg_object_UNKNOWN_OBJ *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_UNKNOWN_OBJ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_UNKNOWN_OBJ_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_REPEAT_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REPEAT *arg1 = (struct _dwg_entity_REPEAT *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_REPEAT_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REPEAT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REPEAT_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_REPEAT *""'"); 
  }
  arg1 = (struct _dwg_entity_REPEAT *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_REPEAT_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_REPEAT_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REPEAT *arg1 = (struct _dwg_entity_REPEAT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REPEAT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_REPEAT_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_REPEAT *""'"); 
  }
  arg1 = (struct _dwg_entity_REPEAT *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_REPEAT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REPEAT *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_REPEAT", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_REPEAT *)calloc(1, sizeof(struct _dwg_entity_REPEAT));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_REPEAT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_REPEAT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_REPEAT *arg1 = (struct _dwg_entity_REPEAT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_REPEAT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_REPEAT" "', argument " "1"" of type '" "struct _dwg_entity_REPEAT *""'"); 
  }
  arg1 = (struct _dwg_entity_REPEAT *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_REPEAT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_REPEAT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_REPEAT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDREP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_ENDREP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_numcols_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDREP_numcols_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_numcols_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ENDREP_numcols_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numcols = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_numcols_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_numcols_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  result = (BITCODE_RS) ((arg1)->numcols);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_numrows_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDREP_numrows_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_numrows_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ENDREP_numrows_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numrows = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_numrows_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_numrows_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  result = (BITCODE_RS) ((arg1)->numrows);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_colspacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDREP_colspacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_colspacing_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ENDREP_colspacing_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->colspacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_colspacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_colspacing_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  result = (BITCODE_RD) ((arg1)->colspacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_rowspacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_ENDREP_rowspacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_rowspacing_set" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_ENDREP_rowspacing_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->rowspacing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_ENDREP_rowspacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_ENDREP_rowspacing_get" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  result = (BITCODE_RD) ((arg1)->rowspacing);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_ENDREP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_ENDREP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_ENDREP *)calloc(1, sizeof(struct _dwg_entity_ENDREP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDREP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_ENDREP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_ENDREP *arg1 = (struct _dwg_entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_ENDREP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_ENDREP" "', argument " "1"" of type '" "struct _dwg_entity_ENDREP *""'"); 
  }
  arg1 = (struct _dwg_entity_ENDREP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_ENDREP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_ENDREP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_ENDREP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_LOAD_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *arg1 = (struct _dwg_entity_LOAD *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOAD_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOAD_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_LOAD *""'"); 
  }
  arg1 = (struct _dwg_entity_LOAD *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOAD_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOAD_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *arg1 = (struct _dwg_entity_LOAD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOAD_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_LOAD *""'"); 
  }
  arg1 = (struct _dwg_entity_LOAD *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOAD_file_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *arg1 = (struct _dwg_entity_LOAD *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_LOAD_file_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOAD_file_name_set" "', argument " "1"" of type '" "struct _dwg_entity_LOAD *""'"); 
  }
  arg1 = (struct _dwg_entity_LOAD *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_LOAD_file_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->file_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->file_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->file_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_LOAD_file_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *arg1 = (struct _dwg_entity_LOAD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_LOAD_file_name_get" "', argument " "1"" of type '" "struct _dwg_entity_LOAD *""'"); 
  }
  arg1 = (struct _dwg_entity_LOAD *)(argp1);
  result = (BITCODE_TV) ((arg1)->file_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_LOAD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_LOAD", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_LOAD *)calloc(1, sizeof(struct _dwg_entity_LOAD));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LOAD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_LOAD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_LOAD *arg1 = (struct _dwg_entity_LOAD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_LOAD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_LOAD" "', argument " "1"" of type '" "struct _dwg_entity_LOAD *""'"); 
  }
  arg1 = (struct _dwg_entity_LOAD *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_LOAD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_LOAD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_LOAD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_JUMP_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity_JUMP_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_address_raw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_JUMP_jump_address_raw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_address_raw_set" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_JUMP_jump_address_raw_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->jump_address_raw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_address_raw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_address_raw_get" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  result = (BITCODE_RL) ((arg1)->jump_address_raw);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_JUMP_jump_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_address_set" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_JUMP_jump_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->jump_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_address_get" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  result = (BITCODE_RL) ((arg1)->jump_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_entity_section_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  Dwg_Entity_Sections arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity_JUMP_jump_entity_section_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_entity_section_set" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity_JUMP_jump_entity_section_set" "', argument " "2"" of type '" "Dwg_Entity_Sections""'");
  } 
  arg2 = (Dwg_Entity_Sections)(val2);
  if (arg1) (arg1)->jump_entity_section = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity_JUMP_jump_entity_section_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_Sections result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity_JUMP_jump_entity_section_get" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  result = (Dwg_Entity_Sections) ((arg1)->jump_entity_section);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity_JUMP", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_JUMP *)calloc(1, sizeof(struct _dwg_entity_JUMP));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_JUMP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_JUMP *arg1 = (struct _dwg_entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_JUMP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity_JUMP" "', argument " "1"" of type '" "struct _dwg_entity_JUMP *""'"); 
  }
  arg1 = (struct _dwg_entity_JUMP *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity_JUMP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_JUMP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity_JUMP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  struct _dwg_object_entity *arg2 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DLINE_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_parent_set" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DLINE_parent_set" "', argument " "2"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg2 = (struct _dwg_object_entity *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_parent_get" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  result = (struct _dwg_object_entity *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DLINE_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_start_set" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DLINE_start_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->start = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_start_get" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->start);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DLINE_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_end_set" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DLINE_end_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->end = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_end_get" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->end);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_extrusion_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DLINE_extrusion_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_extrusion_set" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Entity__3DLINE_extrusion_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->extrusion = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_extrusion_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_extrusion_get" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->extrusion);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_thickness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Entity__3DLINE_thickness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_thickness_set" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Entity__3DLINE_thickness_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->thickness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Entity__3DLINE_thickness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Entity__3DLINE_thickness_get" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  result = (BITCODE_RD) ((arg1)->thickness);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Entity__3DLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Entity__3DLINE", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_3DLINE *)calloc(1, sizeof(struct _dwg_entity_3DLINE));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DLINE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Entity__3DLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_3DLINE *arg1 = (struct _dwg_entity_3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Entity__3DLINE" "', argument " "1"" of type '" "struct _dwg_entity_3DLINE *""'"); 
  }
  arg1 = (struct _dwg_entity_3DLINE *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Entity__3DLINE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_3DLINE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Entity__3DLINE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Eed_Data_u_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *arg1 = (struct _dwg_entity_eed_data *) 0 ;
  union eed_data_t *arg2 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_Data_u_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_Data_u_set" "', argument " "1"" of type '" "struct _dwg_entity_eed_data *""'"); 
  }
  arg1 = (struct _dwg_entity_eed_data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Eed_Data_u_set" "', argument " "2"" of type '" "union eed_data_t *""'"); 
  }
  arg2 = (union eed_data_t *)(argp2);
  if (arg1) (arg1)->u = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_Data_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *arg1 = (struct _dwg_entity_eed_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  union eed_data_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_Data_u_get" "', argument " "1"" of type '" "struct _dwg_entity_eed_data *""'"); 
  }
  arg1 = (struct _dwg_entity_eed_data *)(argp1);
  result = (union eed_data_t *)& ((arg1)->u);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_Data_code_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *arg1 = (struct _dwg_entity_eed_data *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_Data_code_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_Data_code_set" "', argument " "1"" of type '" "struct _dwg_entity_eed_data *""'"); 
  }
  arg1 = (struct _dwg_entity_eed_data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Eed_Data_code_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->code = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_Data_code_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *arg1 = (struct _dwg_entity_eed_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_Data_code_get" "', argument " "1"" of type '" "struct _dwg_entity_eed_data *""'"); 
  }
  arg1 = (struct _dwg_entity_eed_data *)(argp1);
  result = (BITCODE_RC) ((arg1)->code);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Eed_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Eed_Data", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_eed_data *)calloc(1, sizeof(struct _dwg_entity_eed_data));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_eed_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Eed_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed_data *arg1 = (struct _dwg_entity_eed_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Eed_Data" "', argument " "1"" of type '" "struct _dwg_entity_eed_data *""'"); 
  }
  arg1 = (struct _dwg_entity_eed_data *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Eed_Data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_eed_data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Eed_Data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_0 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_0 *)& ((arg1)->eed_0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_0_r2007 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_0_r2007 *)& ((arg1)->eed_0_r2007);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_1 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_1_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_1 *)& ((arg1)->eed_1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_1, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_2 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_2_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_2 *)& ((arg1)->eed_2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_2, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_3 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_3_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_3 *)& ((arg1)->eed_3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_3, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_4 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_4_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_4 *)& ((arg1)->eed_4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_5 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_5_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_5 *)& ((arg1)->eed_5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_5, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_10_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_10 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_10_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_10 *)& ((arg1)->eed_10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_10, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_40_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_40 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_40_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_40 *)& ((arg1)->eed_40);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_40, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_70_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_70 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_70_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_70 *)& ((arg1)->eed_70);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_70, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_71_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  eed_data_t_eed_71 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_71_get" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  result = (eed_data_t_eed_71 *)& ((arg1)->eed_71);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_71, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t", 0, 0, 0)) SWIG_fail;
  result = (union eed_data_t *)calloc(1, sizeof(union eed_data_t));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  union eed_data_t *arg1 = (union eed_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t" "', argument " "1"" of type '" "union eed_data_t *""'"); 
  }
  arg1 = (union eed_data_t *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_71_rl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_71 *arg1 = (eed_data_t_eed_71 *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_71_rl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_71, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_71_rl_set" "', argument " "1"" of type '" "eed_data_t_eed_71 *""'"); 
  }
  arg1 = (eed_data_t_eed_71 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_71_rl_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->rl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_71_rl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_71 *arg1 = (eed_data_t_eed_71 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_71, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_71_rl_get" "', argument " "1"" of type '" "eed_data_t_eed_71 *""'"); 
  }
  arg1 = (eed_data_t_eed_71 *)(argp1);
  result = (BITCODE_RL) ((arg1)->rl);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_71(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_71 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_71", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_71 *)calloc(1, sizeof(eed_data_t_eed_71));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_71, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_71(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_71 *arg1 = (eed_data_t_eed_71 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_71, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_71" "', argument " "1"" of type '" "eed_data_t_eed_71 *""'"); 
  }
  arg1 = (eed_data_t_eed_71 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_71_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_71, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_71_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_70_rs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_70 *arg1 = (eed_data_t_eed_70 *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_70_rs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_70, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_70_rs_set" "', argument " "1"" of type '" "eed_data_t_eed_70 *""'"); 
  }
  arg1 = (eed_data_t_eed_70 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_70_rs_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->rs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_70_rs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_70 *arg1 = (eed_data_t_eed_70 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_70, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_70_rs_get" "', argument " "1"" of type '" "eed_data_t_eed_70 *""'"); 
  }
  arg1 = (eed_data_t_eed_70 *)(argp1);
  result = (BITCODE_RS) ((arg1)->rs);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_70(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_70 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_70", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_70 *)calloc(1, sizeof(eed_data_t_eed_70));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_70, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_70(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_70 *arg1 = (eed_data_t_eed_70 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_70, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_70" "', argument " "1"" of type '" "eed_data_t_eed_70 *""'"); 
  }
  arg1 = (eed_data_t_eed_70 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_70_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_70, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_70_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_40_real_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_40 *arg1 = (eed_data_t_eed_40 *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_40_real_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_40, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_40_real_set" "', argument " "1"" of type '" "eed_data_t_eed_40 *""'"); 
  }
  arg1 = (eed_data_t_eed_40 *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_40_real_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->real = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_40_real_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_40 *arg1 = (eed_data_t_eed_40 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_40, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_40_real_get" "', argument " "1"" of type '" "eed_data_t_eed_40 *""'"); 
  }
  arg1 = (eed_data_t_eed_40 *)(argp1);
  result = (BITCODE_RD) ((arg1)->real);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_40(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_40 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_40", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_40 *)calloc(1, sizeof(eed_data_t_eed_40));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_40, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_40(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_40 *arg1 = (eed_data_t_eed_40 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_40, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_40" "', argument " "1"" of type '" "eed_data_t_eed_40 *""'"); 
  }
  arg1 = (eed_data_t_eed_40 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_40_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_40, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_40_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_10_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_10 *arg1 = (eed_data_t_eed_10 *) 0 ;
  BITCODE_3RD *arg2 = (BITCODE_3RD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_10_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_10, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_10_point_set" "', argument " "1"" of type '" "eed_data_t_eed_10 *""'"); 
  }
  arg1 = (eed_data_t_eed_10 *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eed_data_t_eed_10_point_set" "', argument " "2"" of type '" "BITCODE_3RD *""'"); 
  }
  arg2 = (BITCODE_3RD *)(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_10_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_10 *arg1 = (eed_data_t_eed_10 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_3RD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_10, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_10_point_get" "', argument " "1"" of type '" "eed_data_t_eed_10 *""'"); 
  }
  arg1 = (eed_data_t_eed_10 *)(argp1);
  result = (BITCODE_3RD *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_bitcode_3rd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_10(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_10 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_10", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_10 *)calloc(1, sizeof(eed_data_t_eed_10));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_10, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_10(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_10 *arg1 = (eed_data_t_eed_10 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_10, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_10" "', argument " "1"" of type '" "eed_data_t_eed_10 *""'"); 
  }
  arg1 = (eed_data_t_eed_10 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_10_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_10, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_10_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_5_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_5 *arg1 = (eed_data_t_eed_5 *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_5_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_5, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_5_entity_set" "', argument " "1"" of type '" "eed_data_t_eed_5 *""'"); 
  }
  arg1 = (eed_data_t_eed_5 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_5_entity_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_5_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_5 *arg1 = (eed_data_t_eed_5 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_5, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_5_entity_get" "', argument " "1"" of type '" "eed_data_t_eed_5 *""'"); 
  }
  arg1 = (eed_data_t_eed_5 *)(argp1);
  result = (BITCODE_RLL) ((arg1)->entity);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_5(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_5 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_5", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_5 *)calloc(1, sizeof(eed_data_t_eed_5));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_5, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_5(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_5 *arg1 = (eed_data_t_eed_5 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_5, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_5" "', argument " "1"" of type '" "eed_data_t_eed_5 *""'"); 
  }
  arg1 = (eed_data_t_eed_5 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_5_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_5, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_5_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_4_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_4 *arg1 = (eed_data_t_eed_4 *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_4_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_4_length_set" "', argument " "1"" of type '" "eed_data_t_eed_4 *""'"); 
  }
  arg1 = (eed_data_t_eed_4 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_4_length_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_4_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_4 *arg1 = (eed_data_t_eed_4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_4_length_get" "', argument " "1"" of type '" "eed_data_t_eed_4 *""'"); 
  }
  arg1 = (eed_data_t_eed_4 *)(argp1);
  result = (BITCODE_RC) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_4_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_4 *arg1 = (eed_data_t_eed_4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_4_data_get" "', argument " "1"" of type '" "eed_data_t_eed_4 *""'"); 
  }
  arg1 = (eed_data_t_eed_4 *)(argp1);
  result = (unsigned char *)(unsigned char *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_4 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_4", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_4 *)calloc(1, sizeof(eed_data_t_eed_4));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_4 *arg1 = (eed_data_t_eed_4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_4" "', argument " "1"" of type '" "eed_data_t_eed_4 *""'"); 
  }
  arg1 = (eed_data_t_eed_4 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_3_layer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_3 *arg1 = (eed_data_t_eed_3 *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_3_layer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_3_layer_set" "', argument " "1"" of type '" "eed_data_t_eed_3 *""'"); 
  }
  arg1 = (eed_data_t_eed_3 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_3_layer_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->layer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_3_layer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_3 *arg1 = (eed_data_t_eed_3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_3_layer_get" "', argument " "1"" of type '" "eed_data_t_eed_3 *""'"); 
  }
  arg1 = (eed_data_t_eed_3 *)(argp1);
  result = (BITCODE_RLL) ((arg1)->layer);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_3", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_3 *)calloc(1, sizeof(eed_data_t_eed_3));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_3, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_3 *arg1 = (eed_data_t_eed_3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_3, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_3" "', argument " "1"" of type '" "eed_data_t_eed_3 *""'"); 
  }
  arg1 = (eed_data_t_eed_3 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_2_close_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_2 *arg1 = (eed_data_t_eed_2 *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_2_close_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_2_close_set" "', argument " "1"" of type '" "eed_data_t_eed_2 *""'"); 
  }
  arg1 = (eed_data_t_eed_2 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_2_close_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->close = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_2_close_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_2 *arg1 = (eed_data_t_eed_2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_2_close_get" "', argument " "1"" of type '" "eed_data_t_eed_2 *""'"); 
  }
  arg1 = (eed_data_t_eed_2 *)(argp1);
  result = (BITCODE_RC) ((arg1)->close);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_2", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_2 *)calloc(1, sizeof(eed_data_t_eed_2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_2 *arg1 = (eed_data_t_eed_2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_2" "', argument " "1"" of type '" "eed_data_t_eed_2 *""'"); 
  }
  arg1 = (eed_data_t_eed_2 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_1_appid_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *arg1 = (eed_data_t_eed_1 *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_1_appid_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_1_appid_index_set" "', argument " "1"" of type '" "eed_data_t_eed_1 *""'"); 
  }
  arg1 = (eed_data_t_eed_1 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_1_appid_index_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->appid_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_1_appid_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *arg1 = (eed_data_t_eed_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_1_appid_index_get" "', argument " "1"" of type '" "eed_data_t_eed_1 *""'"); 
  }
  arg1 = (eed_data_t_eed_1 *)(argp1);
  result = (BITCODE_RS) ((arg1)->appid_index);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_1_invalid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *arg1 = (eed_data_t_eed_1 *) 0 ;
  char *arg2 = (char *) (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[0] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_1_invalid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_1_invalid_set" "', argument " "1"" of type '" "eed_data_t_eed_1 *""'"); 
  }
  arg1 = (eed_data_t_eed_1 *)(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eed_data_t_eed_1_invalid_set" "', argument " "2"" of type '" "char [0]""'");
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->invalid,arg2,0*sizeof(char));
  else memset(arg1->invalid,0,0*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_1_invalid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *arg1 = (eed_data_t_eed_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_1_invalid_get" "', argument " "1"" of type '" "eed_data_t_eed_1 *""'"); 
  }
  arg1 = (eed_data_t_eed_1 *)(argp1);
  result = (char *)(char *) ((arg1)->invalid);
  {
    size_t size = SWIG_strnlen(result, 0);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_1", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_1 *)calloc(1, sizeof(eed_data_t_eed_1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_1 *arg1 = (eed_data_t_eed_1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_1, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_1" "', argument " "1"" of type '" "eed_data_t_eed_1 *""'"); 
  }
  arg1 = (eed_data_t_eed_1 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_1, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_r2007_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_length_set" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_r2007_length_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_length_get" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  result = (BITCODE_RS) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007__padding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_r2007__padding_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007__padding_set" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_r2007__padding_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = (unsigned short)(val2);
  if (arg1) (arg1)->_padding = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007__padding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007__padding_get" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  result = (unsigned short) ((arg1)->_padding);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_is_tu_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_r2007_is_tu_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_is_tu_set" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_r2007_is_tu_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = (unsigned short)(val2);
  if (arg1) (arg1)->is_tu = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_is_tu_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_is_tu_get" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  result = (unsigned short) ((arg1)->is_tu);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  dwg_wchar_t *arg2 = (dwg_wchar_t *) (dwg_wchar_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_r2007_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_string_set" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eed_data_t_eed_0_r2007_string_set" "', argument " "2"" of type '" "dwg_wchar_t [0]""'"); 
  } 
  arg2 = (dwg_wchar_t *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)0; ++ii) *(dwg_wchar_t *)&arg1->string[ii] = *((dwg_wchar_t *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""string""' of type '""dwg_wchar_t [0]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_r2007_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  dwg_wchar_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_r2007_string_get" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  result = (dwg_wchar_t *)(dwg_wchar_t *) ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_0_r2007(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_0_r2007", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_0_r2007 *)calloc(1, sizeof(eed_data_t_eed_0_r2007));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_0_r2007, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_0_r2007(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0_r2007 *arg1 = (eed_data_t_eed_0_r2007 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0_r2007, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_0_r2007" "', argument " "1"" of type '" "eed_data_t_eed_0_r2007 *""'"); 
  }
  arg1 = (eed_data_t_eed_0_r2007 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_0_r2007_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_0_r2007, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_0_r2007_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_length_set" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_length_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_length_get" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  result = (BITCODE_RS) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_codepage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_codepage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_codepage_set" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_codepage_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = (unsigned short)(val2);
  if (arg1) (arg1)->codepage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_codepage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_codepage_get" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  result = (unsigned short) ((arg1)->codepage);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_is_tu_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_is_tu_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_is_tu_set" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eed_data_t_eed_0_is_tu_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = (unsigned short)(val2);
  if (arg1) (arg1)->is_tu = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_is_tu_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_is_tu_get" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  result = (unsigned short) ((arg1)->is_tu);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  char *arg2 = (char *) (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[0] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "eed_data_t_eed_0_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_string_set" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eed_data_t_eed_0_string_set" "', argument " "2"" of type '" "char [0]""'");
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->string,arg2,0*sizeof(char));
  else memset(arg1->string,0,0*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eed_data_t_eed_0_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eed_data_t_eed_0_string_get" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  result = (char *)(char *) ((arg1)->string);
  {
    size_t size = SWIG_strnlen(result, 0);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_eed_data_t_eed_0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_eed_data_t_eed_0", 0, 0, 0)) SWIG_fail;
  result = (eed_data_t_eed_0 *)calloc(1, sizeof(eed_data_t_eed_0));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eed_data_t_eed_0, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_eed_data_t_eed_0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  eed_data_t_eed_0 *arg1 = (eed_data_t_eed_0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_eed_data_t_eed_0, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_eed_data_t_eed_0" "', argument " "1"" of type '" "eed_data_t_eed_0 *""'"); 
  }
  arg1 = (eed_data_t_eed_0 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *eed_data_t_eed_0_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_eed_data_t_eed_0, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *eed_data_t_eed_0_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Eed_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_size_set" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Eed_size_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_size_get" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  result = (BITCODE_BS) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  Dwg_Handle *arg2 = (Dwg_Handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_handle_set" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Eed_handle_set" "', argument " "2"" of type '" "Dwg_Handle *""'"); 
  }
  arg2 = (Dwg_Handle *)(argp2);
  if (arg1) (arg1)->handle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Handle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_handle_get" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  result = (Dwg_Handle *)& ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_handle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  Dwg_Eed_Data *arg2 = (Dwg_Eed_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_data_set" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_eed_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Eed_data_set" "', argument " "2"" of type '" "Dwg_Eed_Data *""'"); 
  }
  arg2 = (Dwg_Eed_Data *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Eed_Data *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_data_get" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  result = (Dwg_Eed_Data *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_eed_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_raw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Eed_raw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_raw_set" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Eed_raw_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->raw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Eed_raw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Eed_raw_get" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  result = (BITCODE_TF) ((arg1)->raw);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Eed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Eed", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_entity_eed *)calloc(1, sizeof(struct _dwg_entity_eed));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_eed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Eed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_entity_eed *arg1 = (struct _dwg_entity_eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_eed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Eed" "', argument " "1"" of type '" "struct _dwg_entity_eed *""'"); 
  }
  arg1 = (struct _dwg_entity_eed *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Eed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_entity_eed, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Eed_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_objid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_objid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_objid_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_objid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->objid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_objid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_objid_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BL) ((arg1)->objid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_tio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_object_entity_tio *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_tio_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (_dwg_object_entity_tio *)& ((arg1)->tio);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_dwg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  struct _dwg_struct *arg2 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_dwg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_dwg_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_dwg_set" "', argument " "2"" of type '" "struct _dwg_struct *""'"); 
  }
  arg2 = (struct _dwg_struct *)(argp2);
  if (arg1) (arg1)->dwg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_dwg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_struct *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_dwg_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (struct _dwg_struct *) ((arg1)->dwg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_num_eed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_num_eed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_num_eed_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_num_eed_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_eed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_num_eed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_num_eed_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_eed);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_eed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  Dwg_Eed *arg2 = (Dwg_Eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_eed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_eed_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_eed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_eed_set" "', argument " "2"" of type '" "Dwg_Eed *""'"); 
  }
  arg2 = (Dwg_Eed *)(argp2);
  if (arg1) (arg1)->eed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_eed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Eed *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_eed_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (Dwg_Eed *) ((arg1)->eed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_exists_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_preview_exists_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_exists_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_preview_exists_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->preview_exists = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_exists_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_exists_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->preview_exists);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_is_proxy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_preview_is_proxy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_is_proxy_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_preview_is_proxy_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->preview_is_proxy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_is_proxy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_is_proxy_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->preview_is_proxy);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_preview_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_size_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_preview_size_set" "', argument " "2"" of type '" "BITCODE_BLL""'");
  } 
  arg2 = (BITCODE_BLL)(val2);
  if (arg1) (arg1)->preview_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_size_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BLL) ((arg1)->preview_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_preview_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_preview_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->preview = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_preview_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_preview_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_TF) ((arg1)->preview);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_entmode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_entmode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_entmode_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_entmode_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->entmode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_entmode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_entmode_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BB) ((arg1)->entmode);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_num_reactors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_num_reactors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_num_reactors_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_num_reactors_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_reactors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_num_reactors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_num_reactors_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_reactors);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_is_xdic_missing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_is_xdic_missing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_is_xdic_missing_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_is_xdic_missing_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xdic_missing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_is_xdic_missing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_is_xdic_missing_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xdic_missing);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_isbylayerlt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_isbylayerlt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_isbylayerlt_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_isbylayerlt_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->isbylayerlt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_isbylayerlt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_isbylayerlt_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->isbylayerlt);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_nolinks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_nolinks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_nolinks_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_nolinks_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->nolinks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_nolinks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_nolinks_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->nolinks);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_ds_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_has_ds_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_ds_data_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_has_ds_data_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_ds_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_ds_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_ds_data_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->has_ds_data);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_CMC *arg2 = (BITCODE_CMC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_color_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_color, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_color_set" "', argument " "2"" of type '" "BITCODE_CMC *""'"); 
  }
  arg2 = (BITCODE_CMC *)(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_CMC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_color_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_CMC *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_color, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_ltype_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_scale_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_ltype_scale_set" "', argument " "2"" of type '" "BITCODE_BD""'");
  } 
  arg2 = (BITCODE_BD)(val2);
  if (arg1) (arg1)->ltype_scale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_scale_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BD) ((arg1)->ltype_scale);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_ltype_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_flags_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_ltype_flags_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->ltype_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_flags_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BB) ((arg1)->ltype_flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_plotstyle_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_plotstyle_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_plotstyle_flags_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_plotstyle_flags_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->plotstyle_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_plotstyle_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_plotstyle_flags_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BB) ((arg1)->plotstyle_flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_material_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BB arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_material_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_material_flags_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_material_flags_set" "', argument " "2"" of type '" "BITCODE_BB""'");
  } 
  arg2 = (BITCODE_BB)(val2);
  if (arg1) (arg1)->material_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_material_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BB result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_material_flags_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BB) ((arg1)->material_flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_shadow_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_shadow_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_shadow_flags_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_shadow_flags_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->shadow_flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_shadow_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_shadow_flags_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RC) ((arg1)->shadow_flags);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_full_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_has_full_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_full_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_has_full_visualstyle_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_full_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_full_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_full_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->has_full_visualstyle);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_face_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_has_face_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_face_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_has_face_visualstyle_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_face_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_face_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_face_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->has_face_visualstyle);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_edge_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_has_edge_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_edge_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_has_edge_visualstyle_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_edge_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_has_edge_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_has_edge_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_B) ((arg1)->has_edge_visualstyle);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_invisible_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_invisible_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_invisible_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_invisible_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->invisible = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_invisible_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_invisible_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BS) ((arg1)->invisible);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_linewt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_linewt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_linewt_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_linewt_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->linewt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_linewt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_linewt_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RC) ((arg1)->linewt);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_flag_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_flag_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_flag_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_flag_r11_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->flag_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_flag_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_flag_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RC) ((arg1)->flag_r11);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_opts_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_opts_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_opts_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_opts_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->opts_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_opts_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_opts_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RS) ((arg1)->opts_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_extra_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_extra_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_extra_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_extra_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->extra_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_extra_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_extra_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RS) ((arg1)->extra_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_color_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_color_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_color_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_color_r11_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->color_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_color_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_color_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RCd) ((arg1)->color_r11);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_elevation_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_elevation_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_elevation_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_elevation_r11_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->elevation_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_elevation_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_elevation_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RD) ((arg1)->elevation_r11);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_thickness_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_RD arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_thickness_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_thickness_r11_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity_thickness_r11_set" "', argument " "2"" of type '" "BITCODE_RD""'");
  } 
  arg2 = (BITCODE_RD)(val2);
  if (arg1) (arg1)->thickness_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_thickness_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RD result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_thickness_r11_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_RD) ((arg1)->thickness_r11);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_viewport_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_viewport_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_viewport_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_viewport_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->viewport = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_viewport_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_viewport_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->viewport);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity___iterator_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity___iterator_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity___iterator_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Entity___iterator_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->__iterator = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity___iterator_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity___iterator_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_BL) ((arg1)->__iterator);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ownerhandle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_ownerhandle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ownerhandle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_ownerhandle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ownerhandle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ownerhandle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ownerhandle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->ownerhandle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_reactors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_reactors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_reactors_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_reactors_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->reactors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_reactors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_reactors_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H *) ((arg1)->reactors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_xdicobjhandle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_xdicobjhandle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_xdicobjhandle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_xdicobjhandle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xdicobjhandle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_xdicobjhandle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_xdicobjhandle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->xdicobjhandle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_prev_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_prev_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_prev_entity_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_prev_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->prev_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_prev_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_prev_entity_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->prev_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_next_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_next_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_next_entity_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_next_entity_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->next_entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_next_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_next_entity_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->next_entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_layer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_layer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_layer_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_layer_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->layer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_layer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_layer_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->layer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_ltype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_ltype_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ltype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_ltype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_ltype_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->ltype);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_material_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_material_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->material = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_material_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->material);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_shadow_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_shadow_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_shadow_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_shadow_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->shadow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_shadow_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_shadow_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->shadow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_plotstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_plotstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_plotstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_plotstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->plotstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_plotstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_plotstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->plotstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_full_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_full_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_full_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_full_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->full_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_full_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_full_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->full_visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_face_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_face_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_face_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_face_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->face_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_face_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_face_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->face_visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_edge_visualstyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Entity_edge_visualstyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_edge_visualstyle_set" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Entity_edge_visualstyle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->edge_visualstyle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Entity_edge_visualstyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Entity_edge_visualstyle_get" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  result = (BITCODE_H) ((arg1)->edge_visualstyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_Entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_Entity", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_entity *)calloc(1, sizeof(struct _dwg_object_entity));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_Entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_entity *arg1 = (struct _dwg_object_entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_Entity" "', argument " "1"" of type '" "struct _dwg_object_entity *""'"); 
  }
  arg1 = (struct _dwg_object_entity *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_Entity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_entity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_Entity_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_UNUSED_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_UNUSED *arg2 = (Dwg_Entity_UNUSED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_UNUSED_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_UNUSED_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_UNUSED_set" "', argument " "2"" of type '" "Dwg_Entity_UNUSED *""'"); 
  }
  arg2 = (Dwg_Entity_UNUSED *)(argp2);
  if (arg1) (arg1)->UNUSED = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_UNUSED_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_UNUSED *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_UNUSED_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_UNUSED *) ((arg1)->UNUSED);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_common_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_DIMENSION_common *arg2 = (Dwg_DIMENSION_common *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_common_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_common_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_DIMENSION_common, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_common_set" "', argument " "2"" of type '" "Dwg_DIMENSION_common *""'"); 
  }
  arg2 = (Dwg_DIMENSION_common *)(argp2);
  if (arg1) (arg1)->DIMENSION_common = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_common_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DIMENSION_common *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_common_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_DIMENSION_common *) ((arg1)->DIMENSION_common);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_DIMENSION_common, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity__3DFACE *arg2 = (Dwg_Entity__3DFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio__3DFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio__3DFACE_set" "', argument " "2"" of type '" "Dwg_Entity__3DFACE *""'"); 
  }
  arg2 = (Dwg_Entity__3DFACE *)(argp2);
  if (arg1) (arg1)->_3DFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity__3DFACE *) ((arg1)->_3DFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DSOLID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity__3DSOLID *arg2 = (Dwg_Entity__3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio__3DSOLID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DSOLID_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio__3DSOLID_set" "', argument " "2"" of type '" "Dwg_Entity__3DSOLID *""'"); 
  }
  arg2 = (Dwg_Entity__3DSOLID *)(argp2);
  if (arg1) (arg1)->_3DSOLID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DSOLID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DSOLID_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity__3DSOLID *) ((arg1)->_3DSOLID);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ARC *arg2 = (Dwg_Entity_ARC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ARC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARC_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ARC, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ARC_set" "', argument " "2"" of type '" "Dwg_Entity_ARC *""'"); 
  }
  arg2 = (Dwg_Entity_ARC *)(argp2);
  if (arg1) (arg1)->ARC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARC_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ARC *) ((arg1)->ARC);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ATTDEF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ATTDEF *arg2 = (Dwg_Entity_ATTDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ATTDEF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ATTDEF_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ATTDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ATTDEF_set" "', argument " "2"" of type '" "Dwg_Entity_ATTDEF *""'"); 
  }
  arg2 = (Dwg_Entity_ATTDEF *)(argp2);
  if (arg1) (arg1)->ATTDEF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ATTDEF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ATTDEF_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ATTDEF *) ((arg1)->ATTDEF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ATTRIB_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ATTRIB *arg2 = (Dwg_Entity_ATTRIB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ATTRIB_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ATTRIB_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ATTRIB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ATTRIB_set" "', argument " "2"" of type '" "Dwg_Entity_ATTRIB *""'"); 
  }
  arg2 = (Dwg_Entity_ATTRIB *)(argp2);
  if (arg1) (arg1)->ATTRIB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ATTRIB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTRIB *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ATTRIB_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ATTRIB *) ((arg1)->ATTRIB);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BLOCK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_BLOCK *arg2 = (Dwg_Entity_BLOCK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_BLOCK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BLOCK_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_BLOCK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_BLOCK_set" "', argument " "2"" of type '" "Dwg_Entity_BLOCK *""'"); 
  }
  arg2 = (Dwg_Entity_BLOCK *)(argp2);
  if (arg1) (arg1)->BLOCK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BLOCK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BLOCK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BLOCK_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_BLOCK *) ((arg1)->BLOCK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_BODY *arg2 = (Dwg_Entity_BODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_BODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BODY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_BODY_set" "', argument " "2"" of type '" "Dwg_Entity_BODY *""'"); 
  }
  arg2 = (Dwg_Entity_BODY *)(argp2);
  if (arg1) (arg1)->BODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BODY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_BODY *) ((arg1)->BODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_CIRCLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_CIRCLE *arg2 = (Dwg_Entity_CIRCLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_CIRCLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_CIRCLE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_CIRCLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_CIRCLE_set" "', argument " "2"" of type '" "Dwg_Entity_CIRCLE *""'"); 
  }
  arg2 = (Dwg_Entity_CIRCLE *)(argp2);
  if (arg1) (arg1)->CIRCLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_CIRCLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CIRCLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_CIRCLE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_CIRCLE *) ((arg1)->CIRCLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ALIGNED_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_ALIGNED *arg2 = (Dwg_Entity_DIMENSION_ALIGNED *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_ALIGNED_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ALIGNED_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_ALIGNED_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_ALIGNED *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_ALIGNED *)(argp2);
  if (arg1) (arg1)->DIMENSION_ALIGNED = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ALIGNED_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ALIGNED *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ALIGNED_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_ALIGNED *) ((arg1)->DIMENSION_ALIGNED);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ANG2LN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_ANG2LN *arg2 = (Dwg_Entity_DIMENSION_ANG2LN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_ANG2LN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG2LN_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG2LN_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_ANG2LN *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_ANG2LN *)(argp2);
  if (arg1) (arg1)->DIMENSION_ANG2LN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ANG2LN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG2LN *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG2LN_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG2LN *) ((arg1)->DIMENSION_ANG2LN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ANG3PT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_ANG3PT *arg2 = (Dwg_Entity_DIMENSION_ANG3PT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_ANG3PT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG3PT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG3PT_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_ANG3PT *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_ANG3PT *)(argp2);
  if (arg1) (arg1)->DIMENSION_ANG3PT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ANG3PT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG3PT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ANG3PT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG3PT *) ((arg1)->DIMENSION_ANG3PT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_DIAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_DIAMETER *arg2 = (Dwg_Entity_DIMENSION_DIAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_DIAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_DIAMETER_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_DIAMETER_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_DIAMETER *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_DIAMETER *)(argp2);
  if (arg1) (arg1)->DIMENSION_DIAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_DIAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_DIAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_DIAMETER_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_DIAMETER *) ((arg1)->DIMENSION_DIAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_LINEAR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_LINEAR *arg2 = (Dwg_Entity_DIMENSION_LINEAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_LINEAR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_LINEAR_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_LINEAR_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_LINEAR *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_LINEAR *)(argp2);
  if (arg1) (arg1)->DIMENSION_LINEAR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_LINEAR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_LINEAR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_LINEAR_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_LINEAR *) ((arg1)->DIMENSION_LINEAR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ORDINATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_ORDINATE *arg2 = (Dwg_Entity_DIMENSION_ORDINATE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_ORDINATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ORDINATE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_ORDINATE_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_ORDINATE *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_ORDINATE *)(argp2);
  if (arg1) (arg1)->DIMENSION_ORDINATE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_ORDINATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ORDINATE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_ORDINATE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_ORDINATE *) ((arg1)->DIMENSION_ORDINATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_RADIUS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DIMENSION_RADIUS *arg2 = (Dwg_Entity_DIMENSION_RADIUS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DIMENSION_RADIUS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_RADIUS_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DIMENSION_RADIUS_set" "', argument " "2"" of type '" "Dwg_Entity_DIMENSION_RADIUS *""'"); 
  }
  arg2 = (Dwg_Entity_DIMENSION_RADIUS *)(argp2);
  if (arg1) (arg1)->DIMENSION_RADIUS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DIMENSION_RADIUS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_RADIUS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DIMENSION_RADIUS_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DIMENSION_RADIUS *) ((arg1)->DIMENSION_RADIUS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ELLIPSE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ELLIPSE *arg2 = (Dwg_Entity_ELLIPSE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ELLIPSE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ELLIPSE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ELLIPSE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ELLIPSE_set" "', argument " "2"" of type '" "Dwg_Entity_ELLIPSE *""'"); 
  }
  arg2 = (Dwg_Entity_ELLIPSE *)(argp2);
  if (arg1) (arg1)->ELLIPSE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ELLIPSE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ELLIPSE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ELLIPSE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ELLIPSE *) ((arg1)->ELLIPSE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ENDBLK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ENDBLK *arg2 = (Dwg_Entity_ENDBLK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ENDBLK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ENDBLK_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ENDBLK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ENDBLK_set" "', argument " "2"" of type '" "Dwg_Entity_ENDBLK *""'"); 
  }
  arg2 = (Dwg_Entity_ENDBLK *)(argp2);
  if (arg1) (arg1)->ENDBLK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ENDBLK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDBLK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ENDBLK_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ENDBLK *) ((arg1)->ENDBLK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDBLK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_INSERT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_INSERT *arg2 = (Dwg_Entity_INSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_INSERT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_INSERT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_INSERT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_INSERT_set" "', argument " "2"" of type '" "Dwg_Entity_INSERT *""'"); 
  }
  arg2 = (Dwg_Entity_INSERT *)(argp2);
  if (arg1) (arg1)->INSERT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_INSERT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_INSERT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_INSERT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_INSERT *) ((arg1)->INSERT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LEADER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LEADER *arg2 = (Dwg_Entity_LEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LEADER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LEADER_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LEADER_set" "', argument " "2"" of type '" "Dwg_Entity_LEADER *""'"); 
  }
  arg2 = (Dwg_Entity_LEADER *)(argp2);
  if (arg1) (arg1)->LEADER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LEADER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LEADER_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LEADER *) ((arg1)->LEADER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LINE *arg2 = (Dwg_Entity_LINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LINE_set" "', argument " "2"" of type '" "Dwg_Entity_LINE *""'"); 
  }
  arg2 = (Dwg_Entity_LINE *)(argp2);
  if (arg1) (arg1)->LINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LINE *) ((arg1)->LINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LOAD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LOAD *arg2 = (Dwg_Entity_LOAD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LOAD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LOAD_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LOAD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LOAD_set" "', argument " "2"" of type '" "Dwg_Entity_LOAD *""'"); 
  }
  arg2 = (Dwg_Entity_LOAD *)(argp2);
  if (arg1) (arg1)->LOAD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LOAD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LOAD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LOAD_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LOAD *) ((arg1)->LOAD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MINSERT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MINSERT *arg2 = (Dwg_Entity_MINSERT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MINSERT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MINSERT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MINSERT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MINSERT_set" "', argument " "2"" of type '" "Dwg_Entity_MINSERT *""'"); 
  }
  arg2 = (Dwg_Entity_MINSERT *)(argp2);
  if (arg1) (arg1)->MINSERT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MINSERT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MINSERT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MINSERT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MINSERT *) ((arg1)->MINSERT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MLINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MLINE *arg2 = (Dwg_Entity_MLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MLINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MLINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MLINE_set" "', argument " "2"" of type '" "Dwg_Entity_MLINE *""'"); 
  }
  arg2 = (Dwg_Entity_MLINE *)(argp2);
  if (arg1) (arg1)->MLINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MLINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MLINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MLINE *) ((arg1)->MLINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MTEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MTEXT *arg2 = (Dwg_Entity_MTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MTEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MTEXT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MTEXT_set" "', argument " "2"" of type '" "Dwg_Entity_MTEXT *""'"); 
  }
  arg2 = (Dwg_Entity_MTEXT *)(argp2);
  if (arg1) (arg1)->MTEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MTEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MTEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MTEXT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MTEXT *) ((arg1)->MTEXT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_OLEFRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_OLEFRAME *arg2 = (Dwg_Entity_OLEFRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_OLEFRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_OLEFRAME_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_OLEFRAME, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_OLEFRAME_set" "', argument " "2"" of type '" "Dwg_Entity_OLEFRAME *""'"); 
  }
  arg2 = (Dwg_Entity_OLEFRAME *)(argp2);
  if (arg1) (arg1)->OLEFRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_OLEFRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLEFRAME *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_OLEFRAME_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_OLEFRAME *) ((arg1)->OLEFRAME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POINT *arg2 = (Dwg_Entity_POINT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POINT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POINT_set" "', argument " "2"" of type '" "Dwg_Entity_POINT *""'"); 
  }
  arg2 = (Dwg_Entity_POINT *)(argp2);
  if (arg1) (arg1)->POINT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POINT *) ((arg1)->POINT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_2D_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POLYLINE_2D *arg2 = (Dwg_Entity_POLYLINE_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POLYLINE_2D_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_2D_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POLYLINE_2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POLYLINE_2D_set" "', argument " "2"" of type '" "Dwg_Entity_POLYLINE_2D *""'"); 
  }
  arg2 = (Dwg_Entity_POLYLINE_2D *)(argp2);
  if (arg1) (arg1)->POLYLINE_2D = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_2D_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_2D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_2D_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POLYLINE_2D *) ((arg1)->POLYLINE_2D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_3D_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POLYLINE_3D *arg2 = (Dwg_Entity_POLYLINE_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POLYLINE_3D_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_3D_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POLYLINE_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POLYLINE_3D_set" "', argument " "2"" of type '" "Dwg_Entity_POLYLINE_3D *""'"); 
  }
  arg2 = (Dwg_Entity_POLYLINE_3D *)(argp2);
  if (arg1) (arg1)->POLYLINE_3D = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_3D_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_3D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_3D_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POLYLINE_3D *) ((arg1)->POLYLINE_3D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_MESH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POLYLINE_MESH *arg2 = (Dwg_Entity_POLYLINE_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POLYLINE_MESH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_MESH_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POLYLINE_MESH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POLYLINE_MESH_set" "', argument " "2"" of type '" "Dwg_Entity_POLYLINE_MESH *""'"); 
  }
  arg2 = (Dwg_Entity_POLYLINE_MESH *)(argp2);
  if (arg1) (arg1)->POLYLINE_MESH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_MESH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_MESH_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POLYLINE_MESH *) ((arg1)->POLYLINE_MESH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_PFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POLYLINE_PFACE *arg2 = (Dwg_Entity_POLYLINE_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POLYLINE_PFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_PFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POLYLINE_PFACE_set" "', argument " "2"" of type '" "Dwg_Entity_POLYLINE_PFACE *""'"); 
  }
  arg2 = (Dwg_Entity_POLYLINE_PFACE *)(argp2);
  if (arg1) (arg1)->POLYLINE_PFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLYLINE_PFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_PFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLYLINE_PFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POLYLINE_PFACE *) ((arg1)->POLYLINE_PFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PROXY_ENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_PROXY_ENTITY *arg2 = (Dwg_Entity_PROXY_ENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_PROXY_ENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PROXY_ENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_PROXY_ENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_PROXY_ENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_PROXY_ENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_PROXY_ENTITY *)(argp2);
  if (arg1) (arg1)->PROXY_ENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PROXY_ENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PROXY_ENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PROXY_ENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_PROXY_ENTITY *) ((arg1)->PROXY_ENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_RAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_RAY *arg2 = (Dwg_Entity_RAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_RAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_RAY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_RAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_RAY_set" "', argument " "2"" of type '" "Dwg_Entity_RAY *""'"); 
  }
  arg2 = (Dwg_Entity_RAY *)(argp2);
  if (arg1) (arg1)->RAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_RAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_RAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_RAY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_RAY *) ((arg1)->RAY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REGION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_REGION *arg2 = (Dwg_Entity_REGION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_REGION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REGION_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DSOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_REGION_set" "', argument " "2"" of type '" "Dwg_Entity_REGION *""'"); 
  }
  arg2 = (Dwg_Entity_REGION *)(argp2);
  if (arg1) (arg1)->REGION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REGION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REGION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REGION_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_REGION *) ((arg1)->REGION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SEQEND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SEQEND *arg2 = (Dwg_Entity_SEQEND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SEQEND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SEQEND_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SEQEND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SEQEND_set" "', argument " "2"" of type '" "Dwg_Entity_SEQEND *""'"); 
  }
  arg2 = (Dwg_Entity_SEQEND *)(argp2);
  if (arg1) (arg1)->SEQEND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SEQEND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SEQEND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SEQEND_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SEQEND *) ((arg1)->SEQEND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SHAPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SHAPE *arg2 = (Dwg_Entity_SHAPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SHAPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SHAPE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SHAPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SHAPE_set" "', argument " "2"" of type '" "Dwg_Entity_SHAPE *""'"); 
  }
  arg2 = (Dwg_Entity_SHAPE *)(argp2);
  if (arg1) (arg1)->SHAPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SHAPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SHAPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SHAPE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SHAPE *) ((arg1)->SHAPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SOLID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SOLID *arg2 = (Dwg_Entity_SOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SOLID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SOLID_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SOLID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SOLID_set" "', argument " "2"" of type '" "Dwg_Entity_SOLID *""'"); 
  }
  arg2 = (Dwg_Entity_SOLID *)(argp2);
  if (arg1) (arg1)->SOLID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SOLID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SOLID_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SOLID *) ((arg1)->SOLID);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SPLINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SPLINE *arg2 = (Dwg_Entity_SPLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SPLINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SPLINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SPLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SPLINE_set" "', argument " "2"" of type '" "Dwg_Entity_SPLINE *""'"); 
  }
  arg2 = (Dwg_Entity_SPLINE *)(argp2);
  if (arg1) (arg1)->SPLINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SPLINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SPLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SPLINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SPLINE *) ((arg1)->SPLINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_TEXT *arg2 = (Dwg_Entity_TEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_TEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TEXT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_TEXT_set" "', argument " "2"" of type '" "Dwg_Entity_TEXT *""'"); 
  }
  arg2 = (Dwg_Entity_TEXT *)(argp2);
  if (arg1) (arg1)->TEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TEXT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_TEXT *) ((arg1)->TEXT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TOLERANCE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_TOLERANCE *arg2 = (Dwg_Entity_TOLERANCE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_TOLERANCE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TOLERANCE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TOLERANCE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_TOLERANCE_set" "', argument " "2"" of type '" "Dwg_Entity_TOLERANCE *""'"); 
  }
  arg2 = (Dwg_Entity_TOLERANCE *)(argp2);
  if (arg1) (arg1)->TOLERANCE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TOLERANCE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TOLERANCE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TOLERANCE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_TOLERANCE *) ((arg1)->TOLERANCE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TRACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_TRACE *arg2 = (Dwg_Entity_TRACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_TRACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TRACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TRACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_TRACE_set" "', argument " "2"" of type '" "Dwg_Entity_TRACE *""'"); 
  }
  arg2 = (Dwg_Entity_TRACE *)(argp2);
  if (arg1) (arg1)->TRACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TRACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TRACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TRACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_TRACE *) ((arg1)->TRACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_UNKNOWN_ENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_UNKNOWN_ENT *arg2 = (Dwg_Entity_UNKNOWN_ENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_UNKNOWN_ENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_UNKNOWN_ENT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_UNKNOWN_ENT_set" "', argument " "2"" of type '" "Dwg_Entity_UNKNOWN_ENT *""'"); 
  }
  arg2 = (Dwg_Entity_UNKNOWN_ENT *)(argp2);
  if (arg1) (arg1)->UNKNOWN_ENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_UNKNOWN_ENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_UNKNOWN_ENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_UNKNOWN_ENT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_UNKNOWN_ENT *) ((arg1)->UNKNOWN_ENT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_2D_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VERTEX_2D *arg2 = (Dwg_Entity_VERTEX_2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VERTEX_2D_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_2D_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VERTEX_2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VERTEX_2D_set" "', argument " "2"" of type '" "Dwg_Entity_VERTEX_2D *""'"); 
  }
  arg2 = (Dwg_Entity_VERTEX_2D *)(argp2);
  if (arg1) (arg1)->VERTEX_2D = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_2D_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_2D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_2D_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VERTEX_2D *) ((arg1)->VERTEX_2D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_3D_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VERTEX_3D *arg2 = (Dwg_Entity_VERTEX_3D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VERTEX_3D_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_3D_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VERTEX_3D_set" "', argument " "2"" of type '" "Dwg_Entity_VERTEX_3D *""'"); 
  }
  arg2 = (Dwg_Entity_VERTEX_3D *)(argp2);
  if (arg1) (arg1)->VERTEX_3D = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_3D_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_3D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_3D_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VERTEX_3D *) ((arg1)->VERTEX_3D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_MESH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VERTEX_MESH *arg2 = (Dwg_Entity_VERTEX_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VERTEX_MESH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_MESH_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VERTEX_MESH_set" "', argument " "2"" of type '" "Dwg_Entity_VERTEX_MESH *""'"); 
  }
  arg2 = (Dwg_Entity_VERTEX_MESH *)(argp2);
  if (arg1) (arg1)->VERTEX_MESH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_MESH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_MESH_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VERTEX_MESH *) ((arg1)->VERTEX_MESH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_PFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VERTEX_PFACE *arg2 = (Dwg_Entity_VERTEX_PFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VERTEX_PFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VERTEX_3D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_set" "', argument " "2"" of type '" "Dwg_Entity_VERTEX_PFACE *""'"); 
  }
  arg2 = (Dwg_Entity_VERTEX_PFACE *)(argp2);
  if (arg1) (arg1)->VERTEX_PFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_PFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE *) ((arg1)->VERTEX_PFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_PFACE_FACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VERTEX_PFACE_FACE *arg2 = (Dwg_Entity_VERTEX_PFACE_FACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VERTEX_PFACE_FACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_FACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_FACE_set" "', argument " "2"" of type '" "Dwg_Entity_VERTEX_PFACE_FACE *""'"); 
  }
  arg2 = (Dwg_Entity_VERTEX_PFACE_FACE *)(argp2);
  if (arg1) (arg1)->VERTEX_PFACE_FACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VERTEX_PFACE_FACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE_FACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VERTEX_PFACE_FACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE_FACE *) ((arg1)->VERTEX_PFACE_FACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VIEWPORT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VIEWPORT *arg2 = (Dwg_Entity_VIEWPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VIEWPORT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VIEWPORT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VIEWPORT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VIEWPORT_set" "', argument " "2"" of type '" "Dwg_Entity_VIEWPORT *""'"); 
  }
  arg2 = (Dwg_Entity_VIEWPORT *)(argp2);
  if (arg1) (arg1)->VIEWPORT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VIEWPORT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VIEWPORT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VIEWPORT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VIEWPORT *) ((arg1)->VIEWPORT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XLINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_XLINE *arg2 = (Dwg_Entity_XLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_XLINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XLINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_RAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_XLINE_set" "', argument " "2"" of type '" "Dwg_Entity_XLINE *""'"); 
  }
  arg2 = (Dwg_Entity_XLINE *)(argp2);
  if (arg1) (arg1)->XLINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XLINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_XLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XLINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_XLINE *) ((arg1)->XLINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DLINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity__3DLINE *arg2 = (Dwg_Entity__3DLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio__3DLINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DLINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_3DLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio__3DLINE_set" "', argument " "2"" of type '" "Dwg_Entity__3DLINE *""'"); 
  }
  arg2 = (Dwg_Entity__3DLINE *)(argp2);
  if (arg1) (arg1)->_3DLINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio__3DLINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio__3DLINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity__3DLINE *) ((arg1)->_3DLINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_CAMERA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_CAMERA *arg2 = (Dwg_Entity_CAMERA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_CAMERA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_CAMERA_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_CAMERA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_CAMERA_set" "', argument " "2"" of type '" "Dwg_Entity_CAMERA *""'"); 
  }
  arg2 = (Dwg_Entity_CAMERA *)(argp2);
  if (arg1) (arg1)->CAMERA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_CAMERA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CAMERA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_CAMERA_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_CAMERA *) ((arg1)->CAMERA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DGNUNDERLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DGNUNDERLAY *arg2 = (Dwg_Entity_DGNUNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DGNUNDERLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DGNUNDERLAY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DGNUNDERLAY_set" "', argument " "2"" of type '" "Dwg_Entity_DGNUNDERLAY *""'"); 
  }
  arg2 = (Dwg_Entity_DGNUNDERLAY *)(argp2);
  if (arg1) (arg1)->DGNUNDERLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DGNUNDERLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DGNUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DGNUNDERLAY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DGNUNDERLAY *) ((arg1)->DGNUNDERLAY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DWFUNDERLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_DWFUNDERLAY *arg2 = (Dwg_Entity_DWFUNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_DWFUNDERLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DWFUNDERLAY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_DWFUNDERLAY_set" "', argument " "2"" of type '" "Dwg_Entity_DWFUNDERLAY *""'"); 
  }
  arg2 = (Dwg_Entity_DWFUNDERLAY *)(argp2);
  if (arg1) (arg1)->DWFUNDERLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_DWFUNDERLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DWFUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_DWFUNDERLAY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_DWFUNDERLAY *) ((arg1)->DWFUNDERLAY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ENDREP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ENDREP *arg2 = (Dwg_Entity_ENDREP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ENDREP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ENDREP_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ENDREP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ENDREP_set" "', argument " "2"" of type '" "Dwg_Entity_ENDREP *""'"); 
  }
  arg2 = (Dwg_Entity_ENDREP *)(argp2);
  if (arg1) (arg1)->ENDREP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ENDREP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDREP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ENDREP_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ENDREP *) ((arg1)->ENDREP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_HATCH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_HATCH *arg2 = (Dwg_Entity_HATCH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_HATCH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_HATCH_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_HATCH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_HATCH_set" "', argument " "2"" of type '" "Dwg_Entity_HATCH *""'"); 
  }
  arg2 = (Dwg_Entity_HATCH *)(argp2);
  if (arg1) (arg1)->HATCH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_HATCH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HATCH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_HATCH_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_HATCH *) ((arg1)->HATCH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_IMAGE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_IMAGE *arg2 = (Dwg_Entity_IMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_IMAGE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_IMAGE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_IMAGE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_IMAGE_set" "', argument " "2"" of type '" "Dwg_Entity_IMAGE *""'"); 
  }
  arg2 = (Dwg_Entity_IMAGE *)(argp2);
  if (arg1) (arg1)->IMAGE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_IMAGE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_IMAGE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_IMAGE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_IMAGE *) ((arg1)->IMAGE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_JUMP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_JUMP *arg2 = (Dwg_Entity_JUMP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_JUMP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_JUMP_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_JUMP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_JUMP_set" "', argument " "2"" of type '" "Dwg_Entity_JUMP *""'"); 
  }
  arg2 = (Dwg_Entity_JUMP *)(argp2);
  if (arg1) (arg1)->JUMP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_JUMP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_JUMP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_JUMP_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_JUMP *) ((arg1)->JUMP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LIGHT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LIGHT *arg2 = (Dwg_Entity_LIGHT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LIGHT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LIGHT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LIGHT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LIGHT_set" "', argument " "2"" of type '" "Dwg_Entity_LIGHT *""'"); 
  }
  arg2 = (Dwg_Entity_LIGHT *)(argp2);
  if (arg1) (arg1)->LIGHT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LIGHT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LIGHT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LIGHT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LIGHT *) ((arg1)->LIGHT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LWPOLYLINE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LWPOLYLINE *arg2 = (Dwg_Entity_LWPOLYLINE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LWPOLYLINE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LWPOLYLINE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LWPOLYLINE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LWPOLYLINE_set" "', argument " "2"" of type '" "Dwg_Entity_LWPOLYLINE *""'"); 
  }
  arg2 = (Dwg_Entity_LWPOLYLINE *)(argp2);
  if (arg1) (arg1)->LWPOLYLINE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LWPOLYLINE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LWPOLYLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LWPOLYLINE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LWPOLYLINE *) ((arg1)->LWPOLYLINE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MESH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MESH *arg2 = (Dwg_Entity_MESH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MESH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MESH_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MESH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MESH_set" "', argument " "2"" of type '" "Dwg_Entity_MESH *""'"); 
  }
  arg2 = (Dwg_Entity_MESH *)(argp2);
  if (arg1) (arg1)->MESH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MESH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MESH_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MESH *) ((arg1)->MESH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MULTILEADER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MULTILEADER *arg2 = (Dwg_Entity_MULTILEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MULTILEADER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MULTILEADER_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MULTILEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MULTILEADER_set" "', argument " "2"" of type '" "Dwg_Entity_MULTILEADER *""'"); 
  }
  arg2 = (Dwg_Entity_MULTILEADER *)(argp2);
  if (arg1) (arg1)->MULTILEADER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MULTILEADER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MULTILEADER_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MULTILEADER *) ((arg1)->MULTILEADER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_OLE2FRAME_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_OLE2FRAME *arg2 = (Dwg_Entity_OLE2FRAME *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_OLE2FRAME_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_OLE2FRAME_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_OLE2FRAME, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_OLE2FRAME_set" "', argument " "2"" of type '" "Dwg_Entity_OLE2FRAME *""'"); 
  }
  arg2 = (Dwg_Entity_OLE2FRAME *)(argp2);
  if (arg1) (arg1)->OLE2FRAME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_OLE2FRAME_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLE2FRAME *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_OLE2FRAME_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_OLE2FRAME *) ((arg1)->OLE2FRAME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PDFUNDERLAY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_PDFUNDERLAY *arg2 = (Dwg_Entity_PDFUNDERLAY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_PDFUNDERLAY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PDFUNDERLAY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractentity_UNDERLAY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_PDFUNDERLAY_set" "', argument " "2"" of type '" "Dwg_Entity_PDFUNDERLAY *""'"); 
  }
  arg2 = (Dwg_Entity_PDFUNDERLAY *)(argp2);
  if (arg1) (arg1)->PDFUNDERLAY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PDFUNDERLAY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PDFUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PDFUNDERLAY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_PDFUNDERLAY *) ((arg1)->PDFUNDERLAY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REPEAT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_REPEAT *arg2 = (Dwg_Entity_REPEAT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_REPEAT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REPEAT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_REPEAT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_REPEAT_set" "', argument " "2"" of type '" "Dwg_Entity_REPEAT *""'"); 
  }
  arg2 = (Dwg_Entity_REPEAT *)(argp2);
  if (arg1) (arg1)->REPEAT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REPEAT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REPEAT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REPEAT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_REPEAT *) ((arg1)->REPEAT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_REPEAT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SECTIONOBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SECTIONOBJECT *arg2 = (Dwg_Entity_SECTIONOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SECTIONOBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SECTIONOBJECT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SECTIONOBJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SECTIONOBJECT_set" "', argument " "2"" of type '" "Dwg_Entity_SECTIONOBJECT *""'"); 
  }
  arg2 = (Dwg_Entity_SECTIONOBJECT *)(argp2);
  if (arg1) (arg1)->SECTIONOBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SECTIONOBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SECTIONOBJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SECTIONOBJECT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SECTIONOBJECT *) ((arg1)->SECTIONOBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_WIPEOUT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_WIPEOUT *arg2 = (Dwg_Entity_WIPEOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_WIPEOUT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_WIPEOUT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_WIPEOUT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_WIPEOUT_set" "', argument " "2"" of type '" "Dwg_Entity_WIPEOUT *""'"); 
  }
  arg2 = (Dwg_Entity_WIPEOUT *)(argp2);
  if (arg1) (arg1)->WIPEOUT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_WIPEOUT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_WIPEOUT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_WIPEOUT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_WIPEOUT *) ((arg1)->WIPEOUT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARC_DIMENSION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ARC_DIMENSION *arg2 = (Dwg_Entity_ARC_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ARC_DIMENSION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARC_DIMENSION_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ARC_DIMENSION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ARC_DIMENSION_set" "', argument " "2"" of type '" "Dwg_Entity_ARC_DIMENSION *""'"); 
  }
  arg2 = (Dwg_Entity_ARC_DIMENSION *)(argp2);
  if (arg1) (arg1)->ARC_DIMENSION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARC_DIMENSION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC_DIMENSION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARC_DIMENSION_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ARC_DIMENSION *) ((arg1)->ARC_DIMENSION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_HELIX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_HELIX *arg2 = (Dwg_Entity_HELIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_HELIX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_HELIX_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_HELIX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_HELIX_set" "', argument " "2"" of type '" "Dwg_Entity_HELIX *""'"); 
  }
  arg2 = (Dwg_Entity_HELIX *)(argp2);
  if (arg1) (arg1)->HELIX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_HELIX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HELIX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_HELIX_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_HELIX *) ((arg1)->HELIX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LARGE_RADIAL_DIMENSION *arg2 = (Dwg_Entity_LARGE_RADIAL_DIMENSION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set" "', argument " "2"" of type '" "Dwg_Entity_LARGE_RADIAL_DIMENSION *""'"); 
  }
  arg2 = (Dwg_Entity_LARGE_RADIAL_DIMENSION *)(argp2);
  if (arg1) (arg1)->LARGE_RADIAL_DIMENSION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LARGE_RADIAL_DIMENSION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LARGE_RADIAL_DIMENSION *) ((arg1)->LARGE_RADIAL_DIMENSION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LAYOUTPRINTCONFIG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LAYOUTPRINTCONFIG *arg2 = (Dwg_Entity_LAYOUTPRINTCONFIG *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_set" "', argument " "2"" of type '" "Dwg_Entity_LAYOUTPRINTCONFIG *""'"); 
  }
  arg2 = (Dwg_Entity_LAYOUTPRINTCONFIG *)(argp2);
  if (arg1) (arg1)->LAYOUTPRINTCONFIG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LAYOUTPRINTCONFIG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LAYOUTPRINTCONFIG *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LAYOUTPRINTCONFIG *) ((arg1)->LAYOUTPRINTCONFIG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PLANESURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_PLANESURFACE *arg2 = (Dwg_Entity_PLANESURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_PLANESURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PLANESURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_PLANESURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_PLANESURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_PLANESURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_PLANESURFACE *)(argp2);
  if (arg1) (arg1)->PLANESURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_PLANESURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PLANESURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_PLANESURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_PLANESURFACE *) ((arg1)->PLANESURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTCLOUD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POINTCLOUD *arg2 = (Dwg_Entity_POINTCLOUD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POINTCLOUD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTCLOUD_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTCLOUD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POINTCLOUD_set" "', argument " "2"" of type '" "Dwg_Entity_POINTCLOUD *""'"); 
  }
  arg2 = (Dwg_Entity_POINTCLOUD *)(argp2);
  if (arg1) (arg1)->POINTCLOUD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTCLOUD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTCLOUD_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POINTCLOUD *) ((arg1)->POINTCLOUD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTCLOUDEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POINTCLOUDEX *arg2 = (Dwg_Entity_POINTCLOUDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POINTCLOUDEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTCLOUDEX_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTCLOUDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POINTCLOUDEX_set" "', argument " "2"" of type '" "Dwg_Entity_POINTCLOUDEX *""'"); 
  }
  arg2 = (Dwg_Entity_POINTCLOUDEX *)(argp2);
  if (arg1) (arg1)->POINTCLOUDEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTCLOUDEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTCLOUDEX_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POINTCLOUDEX *) ((arg1)->POINTCLOUDEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ALIGNMENTPARAMETERENTITY *arg2 = (Dwg_Entity_ALIGNMENTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_ALIGNMENTPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_ALIGNMENTPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->ALIGNMENTPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ALIGNMENTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ALIGNMENTPARAMETERENTITY *) ((arg1)->ALIGNMENTPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ALIGNMENTPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARCALIGNEDTEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ARCALIGNEDTEXT *arg2 = (Dwg_Entity_ARCALIGNEDTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ARCALIGNEDTEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARCALIGNEDTEXT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ARCALIGNEDTEXT_set" "', argument " "2"" of type '" "Dwg_Entity_ARCALIGNEDTEXT *""'"); 
  }
  arg2 = (Dwg_Entity_ARCALIGNEDTEXT *)(argp2);
  if (arg1) (arg1)->ARCALIGNEDTEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ARCALIGNEDTEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARCALIGNEDTEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ARCALIGNEDTEXT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ARCALIGNEDTEXT *) ((arg1)->ARCALIGNEDTEXT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARCALIGNEDTEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_BASEPOINTPARAMETERENTITY *arg2 = (Dwg_Entity_BASEPOINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_BASEPOINTPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_BASEPOINTPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->BASEPOINTPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BASEPOINTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_BASEPOINTPARAMETERENTITY *) ((arg1)->BASEPOINTPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_BASEPOINTPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_EXTRUDEDSURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_EXTRUDEDSURFACE *arg2 = (Dwg_Entity_EXTRUDEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_EXTRUDEDSURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_EXTRUDEDSURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_EXTRUDEDSURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_EXTRUDEDSURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_EXTRUDEDSURFACE *)(argp2);
  if (arg1) (arg1)->EXTRUDEDSURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_EXTRUDEDSURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_EXTRUDEDSURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_EXTRUDEDSURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_EXTRUDEDSURFACE *) ((arg1)->EXTRUDEDSURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_EXTRUDEDSURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_FLIPGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_FLIPGRIPENTITY *arg2 = (Dwg_Entity_FLIPGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_FLIPGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_FLIPGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_FLIPGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_FLIPGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_FLIPGRIPENTITY *)(argp2);
  if (arg1) (arg1)->FLIPGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_FLIPGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_FLIPGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_FLIPGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_FLIPGRIPENTITY *) ((arg1)->FLIPGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_FLIPGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_FLIPPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_FLIPPARAMETERENTITY *arg2 = (Dwg_Entity_FLIPPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_FLIPPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_FLIPPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_FLIPPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_FLIPPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_FLIPPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->FLIPPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_FLIPPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_FLIPPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_FLIPPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_FLIPPARAMETERENTITY *) ((arg1)->FLIPPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_FLIPPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_GEOPOSITIONMARKER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_GEOPOSITIONMARKER *arg2 = (Dwg_Entity_GEOPOSITIONMARKER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_GEOPOSITIONMARKER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_GEOPOSITIONMARKER_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_GEOPOSITIONMARKER_set" "', argument " "2"" of type '" "Dwg_Entity_GEOPOSITIONMARKER *""'"); 
  }
  arg2 = (Dwg_Entity_GEOPOSITIONMARKER *)(argp2);
  if (arg1) (arg1)->GEOPOSITIONMARKER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_GEOPOSITIONMARKER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_GEOPOSITIONMARKER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_GEOPOSITIONMARKER_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_GEOPOSITIONMARKER *) ((arg1)->GEOPOSITIONMARKER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_GEOPOSITIONMARKER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINEARGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LINEARGRIPENTITY *arg2 = (Dwg_Entity_LINEARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LINEARGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINEARGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LINEARGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_LINEARGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_LINEARGRIPENTITY *)(argp2);
  if (arg1) (arg1)->LINEARGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINEARGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LINEARGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINEARGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LINEARGRIPENTITY *) ((arg1)->LINEARGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINEARGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINEARPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LINEARPARAMETERENTITY *arg2 = (Dwg_Entity_LINEARPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LINEARPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINEARPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LINEARPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_LINEARPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_LINEARPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->LINEARPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LINEARPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LINEARPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LINEARPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LINEARPARAMETERENTITY *) ((arg1)->LINEARPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINEARPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LOFTEDSURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_LOFTEDSURFACE *arg2 = (Dwg_Entity_LOFTEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_LOFTEDSURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LOFTEDSURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_LOFTEDSURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_LOFTEDSURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_LOFTEDSURFACE *)(argp2);
  if (arg1) (arg1)->LOFTEDSURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_LOFTEDSURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LOFTEDSURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_LOFTEDSURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_LOFTEDSURFACE *) ((arg1)->LOFTEDSURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LOFTEDSURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MPOLYGON_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_MPOLYGON *arg2 = (Dwg_Entity_MPOLYGON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_MPOLYGON_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MPOLYGON_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_MPOLYGON, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_MPOLYGON_set" "', argument " "2"" of type '" "Dwg_Entity_MPOLYGON *""'"); 
  }
  arg2 = (Dwg_Entity_MPOLYGON *)(argp2);
  if (arg1) (arg1)->MPOLYGON = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_MPOLYGON_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MPOLYGON *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_MPOLYGON_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_MPOLYGON *) ((arg1)->MPOLYGON);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MPOLYGON, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_NAVISWORKSMODEL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_NAVISWORKSMODEL *arg2 = (Dwg_Entity_NAVISWORKSMODEL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_NAVISWORKSMODEL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_NAVISWORKSMODEL_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_NAVISWORKSMODEL_set" "', argument " "2"" of type '" "Dwg_Entity_NAVISWORKSMODEL *""'"); 
  }
  arg2 = (Dwg_Entity_NAVISWORKSMODEL *)(argp2);
  if (arg1) (arg1)->NAVISWORKSMODEL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_NAVISWORKSMODEL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_NAVISWORKSMODEL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_NAVISWORKSMODEL_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_NAVISWORKSMODEL *) ((arg1)->NAVISWORKSMODEL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_NAVISWORKSMODEL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_NURBSURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_NURBSURFACE *arg2 = (Dwg_Entity_NURBSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_NURBSURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_NURBSURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_NURBSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_NURBSURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_NURBSURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_NURBSURFACE *)(argp2);
  if (arg1) (arg1)->NURBSURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_NURBSURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_NURBSURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_NURBSURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_NURBSURFACE *) ((arg1)->NURBSURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_NURBSURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POINTPARAMETERENTITY *arg2 = (Dwg_Entity_POINTPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POINTPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POINTPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_POINTPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_POINTPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->POINTPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POINTPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POINTPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POINTPARAMETERENTITY *) ((arg1)->POINTPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLARGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_POLARGRIPENTITY *arg2 = (Dwg_Entity_POLARGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_POLARGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLARGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_POLARGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_POLARGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_POLARGRIPENTITY *)(argp2);
  if (arg1) (arg1)->POLARGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_POLARGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLARGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_POLARGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_POLARGRIPENTITY *) ((arg1)->POLARGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLARGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REVOLVEDSURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_REVOLVEDSURFACE *arg2 = (Dwg_Entity_REVOLVEDSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_REVOLVEDSURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REVOLVEDSURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_REVOLVEDSURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_REVOLVEDSURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_REVOLVEDSURFACE *)(argp2);
  if (arg1) (arg1)->REVOLVEDSURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_REVOLVEDSURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REVOLVEDSURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_REVOLVEDSURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_REVOLVEDSURFACE *) ((arg1)->REVOLVEDSURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_REVOLVEDSURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ROTATIONGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ROTATIONGRIPENTITY *arg2 = (Dwg_Entity_ROTATIONGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ROTATIONGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ROTATIONGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ROTATIONGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_ROTATIONGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_ROTATIONGRIPENTITY *)(argp2);
  if (arg1) (arg1)->ROTATIONGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ROTATIONGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ROTATIONGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ROTATIONGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ROTATIONGRIPENTITY *) ((arg1)->ROTATIONGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ROTATIONGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_ROTATIONPARAMETERENTITY *arg2 = (Dwg_Entity_ROTATIONPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_ROTATIONPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_ROTATIONPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->ROTATIONPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_ROTATIONPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ROTATIONPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_ROTATIONPARAMETERENTITY *) ((arg1)->ROTATIONPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ROTATIONPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_RTEXT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_RTEXT *arg2 = (Dwg_Entity_RTEXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_RTEXT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_RTEXT_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_RTEXT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_RTEXT_set" "', argument " "2"" of type '" "Dwg_Entity_RTEXT *""'"); 
  }
  arg2 = (Dwg_Entity_RTEXT *)(argp2);
  if (arg1) (arg1)->RTEXT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_RTEXT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_RTEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_RTEXT_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_RTEXT *) ((arg1)->RTEXT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RTEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SWEPTSURFACE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_SWEPTSURFACE *arg2 = (Dwg_Entity_SWEPTSURFACE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_SWEPTSURFACE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SWEPTSURFACE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_SWEPTSURFACE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_SWEPTSURFACE_set" "', argument " "2"" of type '" "Dwg_Entity_SWEPTSURFACE *""'"); 
  }
  arg2 = (Dwg_Entity_SWEPTSURFACE *)(argp2);
  if (arg1) (arg1)->SWEPTSURFACE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_SWEPTSURFACE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SWEPTSURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_SWEPTSURFACE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_SWEPTSURFACE *) ((arg1)->SWEPTSURFACE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SWEPTSURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TABLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_TABLE *arg2 = (Dwg_Entity_TABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_TABLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TABLE_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_TABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_TABLE_set" "', argument " "2"" of type '" "Dwg_Entity_TABLE *""'"); 
  }
  arg2 = (Dwg_Entity_TABLE *)(argp2);
  if (arg1) (arg1)->TABLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_TABLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_TABLE_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_TABLE *) ((arg1)->TABLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VISIBILITYGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VISIBILITYGRIPENTITY *arg2 = (Dwg_Entity_VISIBILITYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_VISIBILITYGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_VISIBILITYGRIPENTITY *)(argp2);
  if (arg1) (arg1)->VISIBILITYGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VISIBILITYGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VISIBILITYGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VISIBILITYGRIPENTITY *) ((arg1)->VISIBILITYGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VISIBILITYGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_VISIBILITYPARAMETERENTITY *arg2 = (Dwg_Entity_VISIBILITYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_VISIBILITYPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_VISIBILITYPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->VISIBILITYPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VISIBILITYPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_VISIBILITYPARAMETERENTITY *) ((arg1)->VISIBILITYPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VISIBILITYPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XYGRIPENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_XYGRIPENTITY *arg2 = (Dwg_Entity_XYGRIPENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_XYGRIPENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XYGRIPENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_XYGRIPENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_XYGRIPENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_XYGRIPENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_XYGRIPENTITY *)(argp2);
  if (arg1) (arg1)->XYGRIPENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XYGRIPENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_XYGRIPENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XYGRIPENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_XYGRIPENTITY *) ((arg1)->XYGRIPENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_XYGRIPENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XYPARAMETERENTITY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  Dwg_Entity_XYPARAMETERENTITY *arg2 = (Dwg_Entity_XYPARAMETERENTITY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_entity_tio_XYPARAMETERENTITY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XYPARAMETERENTITY_set" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_entity_tio_XYPARAMETERENTITY_set" "', argument " "2"" of type '" "Dwg_Entity_XYPARAMETERENTITY *""'"); 
  }
  arg2 = (Dwg_Entity_XYPARAMETERENTITY *)(argp2);
  if (arg1) (arg1)->XYPARAMETERENTITY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_entity_tio_XYPARAMETERENTITY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_XYPARAMETERENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_entity_tio_XYPARAMETERENTITY_get" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  result = (Dwg_Entity_XYPARAMETERENTITY *) ((arg1)->XYPARAMETERENTITY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_XYPARAMETERENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_object_entity_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_object_entity_tio", 0, 0, 0)) SWIG_fail;
  result = (_dwg_object_entity_tio *)calloc(1, sizeof(_dwg_object_entity_tio));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity_tio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_object_entity_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_entity_tio *arg1 = (_dwg_object_entity_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity_tio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_object_entity_tio" "', argument " "1"" of type '" "_dwg_object_entity_tio *""'"); 
  }
  arg1 = (_dwg_object_entity_tio *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_object_entity_tio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_entity_tio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_object_entity_tio_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_Object_objid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_objid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_objid_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Object_objid_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->objid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_objid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_objid_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_BL) ((arg1)->objid);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_tio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_object_object_tio *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_tio_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (_dwg_object_object_tio *)& ((arg1)->tio);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_dwg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  struct _dwg_struct *arg2 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_dwg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_dwg_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_dwg_set" "', argument " "2"" of type '" "struct _dwg_struct *""'"); 
  }
  arg2 = (struct _dwg_struct *)(argp2);
  if (arg1) (arg1)->dwg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_dwg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_struct *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_dwg_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (struct _dwg_struct *) ((arg1)->dwg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_num_eed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_num_eed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_num_eed_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Object_num_eed_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_eed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_num_eed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_num_eed_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_eed);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_eed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  Dwg_Eed *arg2 = (Dwg_Eed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_eed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_eed_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_entity_eed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_eed_set" "', argument " "2"" of type '" "Dwg_Eed *""'"); 
  }
  arg2 = (Dwg_Eed *)(argp2);
  if (arg1) (arg1)->eed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_eed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Eed *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_eed_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (Dwg_Eed *) ((arg1)->eed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_eed, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_ownerhandle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_ownerhandle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_ownerhandle_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_ownerhandle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->ownerhandle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_ownerhandle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_ownerhandle_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_H) ((arg1)->ownerhandle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_num_reactors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_num_reactors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_num_reactors_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Object_num_reactors_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_reactors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_num_reactors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_num_reactors_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_reactors);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_reactors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_reactors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_reactors_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_reactors_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->reactors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_reactors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_reactors_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_H *) ((arg1)->reactors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_xdicobjhandle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_xdicobjhandle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_xdicobjhandle_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_xdicobjhandle_set" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  if (arg1) (arg1)->xdicobjhandle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_xdicobjhandle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_xdicobjhandle_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_H) ((arg1)->xdicobjhandle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_is_xdic_missing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_is_xdic_missing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_is_xdic_missing_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Object_is_xdic_missing_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_xdic_missing = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_is_xdic_missing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_is_xdic_missing_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_B) ((arg1)->is_xdic_missing);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_has_ds_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_has_ds_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_has_ds_data_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_Object_has_ds_data_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_ds_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_has_ds_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_has_ds_data_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (BITCODE_B) ((arg1)->has_ds_data);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_handleref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  Dwg_Handle *arg2 = (Dwg_Handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_Object_handleref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_handleref_set" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_handle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_Object_handleref_set" "', argument " "2"" of type '" "Dwg_Handle *""'"); 
  }
  arg2 = (Dwg_Handle *)(argp2);
  if (arg1) (arg1)->handleref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_Object_handleref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Handle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_Object_handleref_get" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  result = (Dwg_Handle *) ((arg1)->handleref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_handle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object_Object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object_Object", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object_object *)calloc(1, sizeof(struct _dwg_object_object));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object_Object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object_object *arg1 = (struct _dwg_object_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object_Object" "', argument " "1"" of type '" "struct _dwg_object_object *""'"); 
  }
  arg1 = (struct _dwg_object_object *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_object, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_Object_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_object_object_tio_APPID_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_APPID *arg2 = (Dwg_Object_APPID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_APPID_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_APPID_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_APPID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_APPID_set" "', argument " "2"" of type '" "Dwg_Object_APPID *""'"); 
  }
  arg2 = (Dwg_Object_APPID *)(argp2);
  if (arg1) (arg1)->APPID = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_APPID_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_APPID_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_APPID *) ((arg1)->APPID);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_APPID_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_APPID_CONTROL *arg2 = (Dwg_Object_APPID_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_APPID_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_APPID_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_APPID_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_APPID_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_APPID_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_APPID_CONTROL *)(argp2);
  if (arg1) (arg1)->APPID_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_APPID_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_APPID_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_APPID_CONTROL *) ((arg1)->APPID_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCK_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCK_CONTROL *arg2 = (Dwg_Object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCK_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCK_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCK_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_BLOCK_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_BLOCK_CONTROL *)(argp2);
  if (arg1) (arg1)->BLOCK_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCK_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCK_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCK_CONTROL *) ((arg1)->BLOCK_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCK_HEADER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCK_HEADER *arg2 = (Dwg_Object_BLOCK_HEADER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCK_HEADER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCK_HEADER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCK_HEADER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCK_HEADER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCK_HEADER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCK_HEADER *)(argp2);
  if (arg1) (arg1)->BLOCK_HEADER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCK_HEADER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_HEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCK_HEADER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCK_HEADER *) ((arg1)->BLOCK_HEADER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DICTIONARY *arg2 = (Dwg_Object_DICTIONARY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DICTIONARY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DICTIONARY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DICTIONARY_set" "', argument " "2"" of type '" "Dwg_Object_DICTIONARY *""'"); 
  }
  arg2 = (Dwg_Object_DICTIONARY *)(argp2);
  if (arg1) (arg1)->DICTIONARY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DICTIONARY *) ((arg1)->DICTIONARY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DIMSTYLE *arg2 = (Dwg_Object_DIMSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DIMSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMSTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DIMSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DIMSTYLE_set" "', argument " "2"" of type '" "Dwg_Object_DIMSTYLE *""'"); 
  }
  arg2 = (Dwg_Object_DIMSTYLE *)(argp2);
  if (arg1) (arg1)->DIMSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMSTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DIMSTYLE *) ((arg1)->DIMSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMSTYLE_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DIMSTYLE_CONTROL *arg2 = (Dwg_Object_DIMSTYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DIMSTYLE_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMSTYLE_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DIMSTYLE_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_DIMSTYLE_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_DIMSTYLE_CONTROL *)(argp2);
  if (arg1) (arg1)->DIMSTYLE_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMSTYLE_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMSTYLE_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DIMSTYLE_CONTROL *) ((arg1)->DIMSTYLE_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DUMMY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DUMMY *arg2 = (Dwg_Object_DUMMY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DUMMY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DUMMY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DUMMY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DUMMY_set" "', argument " "2"" of type '" "Dwg_Object_DUMMY *""'"); 
  }
  arg2 = (Dwg_Object_DUMMY *)(argp2);
  if (arg1) (arg1)->DUMMY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DUMMY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DUMMY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DUMMY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DUMMY *) ((arg1)->DUMMY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DUMMY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LAYER *arg2 = (Dwg_Object_LAYER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LAYER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LAYER_set" "', argument " "2"" of type '" "Dwg_Object_LAYER *""'"); 
  }
  arg2 = (Dwg_Object_LAYER *)(argp2);
  if (arg1) (arg1)->LAYER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LAYER *) ((arg1)->LAYER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LAYER_CONTROL *arg2 = (Dwg_Object_LAYER_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LAYER_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYER_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LAYER_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_LAYER_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_LAYER_CONTROL *)(argp2);
  if (arg1) (arg1)->LAYER_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LAYER_CONTROL *) ((arg1)->LAYER_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LONG_TRANSACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LONG_TRANSACTION *arg2 = (Dwg_Object_LONG_TRANSACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LONG_TRANSACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LONG_TRANSACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LONG_TRANSACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LONG_TRANSACTION_set" "', argument " "2"" of type '" "Dwg_Object_LONG_TRANSACTION *""'"); 
  }
  arg2 = (Dwg_Object_LONG_TRANSACTION *)(argp2);
  if (arg1) (arg1)->LONG_TRANSACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LONG_TRANSACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LONG_TRANSACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LONG_TRANSACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LONG_TRANSACTION *) ((arg1)->LONG_TRANSACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LONG_TRANSACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LTYPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LTYPE *arg2 = (Dwg_Object_LTYPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LTYPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LTYPE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LTYPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LTYPE_set" "', argument " "2"" of type '" "Dwg_Object_LTYPE *""'"); 
  }
  arg2 = (Dwg_Object_LTYPE *)(argp2);
  if (arg1) (arg1)->LTYPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LTYPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LTYPE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LTYPE *) ((arg1)->LTYPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LTYPE_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LTYPE_CONTROL *arg2 = (Dwg_Object_LTYPE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LTYPE_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LTYPE_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LTYPE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LTYPE_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_LTYPE_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_LTYPE_CONTROL *)(argp2);
  if (arg1) (arg1)->LTYPE_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LTYPE_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LTYPE_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LTYPE_CONTROL *) ((arg1)->LTYPE_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLINESTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MLINESTYLE *arg2 = (Dwg_Object_MLINESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MLINESTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLINESTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MLINESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MLINESTYLE_set" "', argument " "2"" of type '" "Dwg_Object_MLINESTYLE *""'"); 
  }
  arg2 = (Dwg_Object_MLINESTYLE *)(argp2);
  if (arg1) (arg1)->MLINESTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLINESTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLINESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLINESTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MLINESTYLE *) ((arg1)->MLINESTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_STYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_STYLE *arg2 = (Dwg_Object_STYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_STYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_STYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_STYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_STYLE_set" "', argument " "2"" of type '" "Dwg_Object_STYLE *""'"); 
  }
  arg2 = (Dwg_Object_STYLE *)(argp2);
  if (arg1) (arg1)->STYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_STYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_STYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_STYLE *) ((arg1)->STYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_STYLE_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_STYLE_CONTROL *arg2 = (Dwg_Object_STYLE_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_STYLE_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_STYLE_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_STYLE_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_STYLE_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_STYLE_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_STYLE_CONTROL *)(argp2);
  if (arg1) (arg1)->STYLE_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_STYLE_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_STYLE_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_STYLE_CONTROL *) ((arg1)->STYLE_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UCS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_UCS *arg2 = (Dwg_Object_UCS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_UCS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UCS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_UCS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_UCS_set" "', argument " "2"" of type '" "Dwg_Object_UCS *""'"); 
  }
  arg2 = (Dwg_Object_UCS *)(argp2);
  if (arg1) (arg1)->UCS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UCS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UCS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_UCS *) ((arg1)->UCS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UCS_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_UCS_CONTROL *arg2 = (Dwg_Object_UCS_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_UCS_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UCS_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_UCS_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_UCS_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_UCS_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_UCS_CONTROL *)(argp2);
  if (arg1) (arg1)->UCS_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UCS_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UCS_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_UCS_CONTROL *) ((arg1)->UCS_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UNKNOWN_OBJ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_UNKNOWN_OBJ *arg2 = (Dwg_Object_UNKNOWN_OBJ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_UNKNOWN_OBJ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UNKNOWN_OBJ_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_UNKNOWN_OBJ_set" "', argument " "2"" of type '" "Dwg_Object_UNKNOWN_OBJ *""'"); 
  }
  arg2 = (Dwg_Object_UNKNOWN_OBJ *)(argp2);
  if (arg1) (arg1)->UNKNOWN_OBJ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_UNKNOWN_OBJ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UNKNOWN_OBJ *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_UNKNOWN_OBJ_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_UNKNOWN_OBJ *) ((arg1)->UNKNOWN_OBJ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VIEW_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VIEW *arg2 = (Dwg_Object_VIEW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VIEW_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VIEW_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VIEW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VIEW_set" "', argument " "2"" of type '" "Dwg_Object_VIEW *""'"); 
  }
  arg2 = (Dwg_Object_VIEW *)(argp2);
  if (arg1) (arg1)->VIEW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VIEW_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VIEW_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VIEW *) ((arg1)->VIEW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VIEW_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VIEW_CONTROL *arg2 = (Dwg_Object_VIEW_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VIEW_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VIEW_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VIEW_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VIEW_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_VIEW_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_VIEW_CONTROL *)(argp2);
  if (arg1) (arg1)->VIEW_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VIEW_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VIEW_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VIEW_CONTROL *) ((arg1)->VIEW_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VPORT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VPORT *arg2 = (Dwg_Object_VPORT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VPORT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VPORT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VPORT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VPORT_set" "', argument " "2"" of type '" "Dwg_Object_VPORT *""'"); 
  }
  arg2 = (Dwg_Object_VPORT *)(argp2);
  if (arg1) (arg1)->VPORT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VPORT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VPORT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VPORT *) ((arg1)->VPORT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VPORT_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VPORT_CONTROL *arg2 = (Dwg_Object_VPORT_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VPORT_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VPORT_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VPORT_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VPORT_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_VPORT_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_VPORT_CONTROL *)(argp2);
  if (arg1) (arg1)->VPORT_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VPORT_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VPORT_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VPORT_CONTROL *) ((arg1)->VPORT_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VX_CONTROL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VX_CONTROL *arg2 = (Dwg_Object_VX_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VX_CONTROL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VX_CONTROL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VX_CONTROL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VX_CONTROL_set" "', argument " "2"" of type '" "Dwg_Object_VX_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_VX_CONTROL *)(argp2);
  if (arg1) (arg1)->VX_CONTROL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VX_CONTROL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VX_CONTROL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VX_CONTROL *) ((arg1)->VX_CONTROL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VX_TABLE_RECORD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VX_TABLE_RECORD *arg2 = (Dwg_Object_VX_TABLE_RECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VX_TABLE_RECORD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VX_TABLE_RECORD_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VX_TABLE_RECORD_set" "', argument " "2"" of type '" "Dwg_Object_VX_TABLE_RECORD *""'"); 
  }
  arg2 = (Dwg_Object_VX_TABLE_RECORD *)(argp2);
  if (arg1) (arg1)->VX_TABLE_RECORD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VX_TABLE_RECORD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_TABLE_RECORD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VX_TABLE_RECORD_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VX_TABLE_RECORD *) ((arg1)->VX_TABLE_RECORD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_BOOLEAN_CLASS *arg2 = (Dwg_Object_ACSH_BOOLEAN_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_BOOLEAN_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_BOOLEAN_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_BOOLEAN_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BOOLEAN_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOOLEAN_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_BOOLEAN_CLASS *) ((arg1)->ACSH_BOOLEAN_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BOX_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_BOX_CLASS *arg2 = (Dwg_Object_ACSH_BOX_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_BOX_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BOX_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_BOX_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_BOX_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_BOX_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_BOX_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BOX_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOX_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BOX_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_BOX_CLASS *) ((arg1)->ACSH_BOX_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CONE_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_CONE_CLASS *arg2 = (Dwg_Object_ACSH_CONE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_CONE_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CONE_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_CONE_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_CONE_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_CONE_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_CONE_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CONE_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CONE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CONE_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_CONE_CLASS *) ((arg1)->ACSH_CONE_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CYLINDER_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_CYLINDER_CLASS *arg2 = (Dwg_Object_ACSH_CYLINDER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_CYLINDER_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_CYLINDER_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_CYLINDER_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CYLINDER_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CYLINDER_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_CYLINDER_CLASS *) ((arg1)->ACSH_CYLINDER_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_FILLET_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_FILLET_CLASS *arg2 = (Dwg_Object_ACSH_FILLET_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_FILLET_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_FILLET_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_FILLET_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_FILLET_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_FILLET_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_FILLET_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_FILLET_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_FILLET_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_FILLET_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_FILLET_CLASS *) ((arg1)->ACSH_FILLET_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_HISTORY_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_HISTORY_CLASS *arg2 = (Dwg_Object_ACSH_HISTORY_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_HISTORY_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_HISTORY_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_HISTORY_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_HISTORY_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_HISTORY_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_HISTORY_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_HISTORY_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_HISTORY_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_HISTORY_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_HISTORY_CLASS *) ((arg1)->ACSH_HISTORY_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_SPHERE_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_SPHERE_CLASS *arg2 = (Dwg_Object_ACSH_SPHERE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_SPHERE_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_SPHERE_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_SPHERE_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_SPHERE_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_SPHERE_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_SPHERE_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_SPHERE_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_SPHERE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_SPHERE_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_SPHERE_CLASS *) ((arg1)->ACSH_SPHERE_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_TORUS_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_TORUS_CLASS *arg2 = (Dwg_Object_ACSH_TORUS_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_TORUS_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_TORUS_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_TORUS_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_TORUS_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_TORUS_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_TORUS_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_TORUS_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_TORUS_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_TORUS_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_TORUS_CLASS *) ((arg1)->ACSH_TORUS_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_WEDGE_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_WEDGE_CLASS *arg2 = (Dwg_Object_ACSH_WEDGE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_WEDGE_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_WEDGE_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_WEDGE_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_WEDGE_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_WEDGE_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_WEDGE_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_WEDGE_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_WEDGE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_WEDGE_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_WEDGE_CLASS *) ((arg1)->ACSH_WEDGE_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCGEOMDEPENDENCY *arg2 = (Dwg_Object_ASSOCGEOMDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCGEOMDEPENDENCY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCGEOMDEPENDENCY *)(argp2);
  if (arg1) (arg1)->ASSOCGEOMDEPENDENCY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCGEOMDEPENDENCY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCGEOMDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCGEOMDEPENDENCY *) ((arg1)->ASSOCGEOMDEPENDENCY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCNETWORK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCNETWORK *arg2 = (Dwg_Object_ASSOCNETWORK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCNETWORK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCNETWORK_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCNETWORK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCNETWORK_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCNETWORK *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCNETWORK *)(argp2);
  if (arg1) (arg1)->ASSOCNETWORK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCNETWORK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCNETWORK_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCNETWORK *) ((arg1)->ASSOCNETWORK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNMENTGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKALIGNMENTGRIP *arg2 = (Dwg_Object_BLOCKALIGNMENTGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKALIGNMENTGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKALIGNMENTGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKALIGNMENTGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNMENTGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTGRIP *) ((arg1)->BLOCKALIGNMENTGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKALIGNMENTPARAMETER *arg2 = (Dwg_Object_BLOCKALIGNMENTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKALIGNMENTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKALIGNMENTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKALIGNMENTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTPARAMETER *) ((arg1)->BLOCKALIGNMENTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKBASEPOINTPARAMETER *arg2 = (Dwg_Object_BLOCKBASEPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKBASEPOINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKBASEPOINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKBASEPOINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKBASEPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKBASEPOINTPARAMETER *) ((arg1)->BLOCKBASEPOINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKFLIPACTION *arg2 = (Dwg_Object_BLOCKFLIPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKFLIPACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKFLIPACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKFLIPACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKFLIPACTION *)(argp2);
  if (arg1) (arg1)->BLOCKFLIPACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKFLIPACTION *) ((arg1)->BLOCKFLIPACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKFLIPGRIP *arg2 = (Dwg_Object_BLOCKFLIPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKFLIPGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKFLIPGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKFLIPGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKFLIPGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKFLIPGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKFLIPGRIP *) ((arg1)->BLOCKFLIPGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKFLIPPARAMETER *arg2 = (Dwg_Object_BLOCKFLIPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKFLIPPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKFLIPPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKFLIPPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKFLIPPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKFLIPPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKFLIPPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKFLIPPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKFLIPPARAMETER *) ((arg1)->BLOCKFLIPPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *arg2 = (Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *)(argp2);
  if (arg1) (arg1)->BLOCKGRIPLOCATIONCOMPONENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *) ((arg1)->BLOCKGRIPLOCATIONCOMPONENT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLINEARGRIP *arg2 = (Dwg_Object_BLOCKLINEARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLINEARGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLINEARGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLINEARGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLINEARGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKLINEARGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLINEARGRIP *) ((arg1)->BLOCKLINEARGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLOOKUPGRIP *arg2 = (Dwg_Object_BLOCKLOOKUPGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLOOKUPGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLOOKUPGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLOOKUPGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKLOOKUPGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPGRIP *) ((arg1)->BLOCKLOOKUPGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKMOVEACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKMOVEACTION *arg2 = (Dwg_Object_BLOCKMOVEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKMOVEACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKMOVEACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKMOVEACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKMOVEACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKMOVEACTION *)(argp2);
  if (arg1) (arg1)->BLOCKMOVEACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKMOVEACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKMOVEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKMOVEACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKMOVEACTION *) ((arg1)->BLOCKMOVEACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATEACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKROTATEACTION *arg2 = (Dwg_Object_BLOCKROTATEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKROTATEACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATEACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKROTATEACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKROTATEACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKROTATEACTION *)(argp2);
  if (arg1) (arg1)->BLOCKROTATEACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATEACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATEACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKROTATEACTION *) ((arg1)->BLOCKROTATEACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATIONGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKROTATIONGRIP *arg2 = (Dwg_Object_BLOCKROTATIONGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKROTATIONGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATIONGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKROTATIONGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKROTATIONGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKROTATIONGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKROTATIONGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATIONGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATIONGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONGRIP *) ((arg1)->BLOCKROTATIONGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKSCALEACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKSCALEACTION *arg2 = (Dwg_Object_BLOCKSCALEACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKSCALEACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKSCALEACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKSCALEACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKSCALEACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKSCALEACTION *)(argp2);
  if (arg1) (arg1)->BLOCKSCALEACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKSCALEACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSCALEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKSCALEACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKSCALEACTION *) ((arg1)->BLOCKSCALEACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVISIBILITYGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKVISIBILITYGRIP *arg2 = (Dwg_Object_BLOCKVISIBILITYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKVISIBILITYGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKVISIBILITYGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKVISIBILITYGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVISIBILITYGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYGRIP *) ((arg1)->BLOCKVISIBILITYGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CELLSTYLEMAP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_CELLSTYLEMAP *arg2 = (Dwg_Object_CELLSTYLEMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_CELLSTYLEMAP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CELLSTYLEMAP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_CELLSTYLEMAP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_CELLSTYLEMAP_set" "', argument " "2"" of type '" "Dwg_Object_CELLSTYLEMAP *""'"); 
  }
  arg2 = (Dwg_Object_CELLSTYLEMAP *)(argp2);
  if (arg1) (arg1)->CELLSTYLEMAP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CELLSTYLEMAP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CELLSTYLEMAP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CELLSTYLEMAP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_CELLSTYLEMAP *) ((arg1)->CELLSTYLEMAP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DETAILVIEWSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DETAILVIEWSTYLE *arg2 = (Dwg_Object_DETAILVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DETAILVIEWSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DETAILVIEWSTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DETAILVIEWSTYLE_set" "', argument " "2"" of type '" "Dwg_Object_DETAILVIEWSTYLE *""'"); 
  }
  arg2 = (Dwg_Object_DETAILVIEWSTYLE *)(argp2);
  if (arg1) (arg1)->DETAILVIEWSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DETAILVIEWSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DETAILVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DETAILVIEWSTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DETAILVIEWSTYLE *) ((arg1)->DETAILVIEWSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARYVAR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DICTIONARYVAR *arg2 = (Dwg_Object_DICTIONARYVAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DICTIONARYVAR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARYVAR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DICTIONARYVAR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DICTIONARYVAR_set" "', argument " "2"" of type '" "Dwg_Object_DICTIONARYVAR *""'"); 
  }
  arg2 = (Dwg_Object_DICTIONARYVAR *)(argp2);
  if (arg1) (arg1)->DICTIONARYVAR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARYVAR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYVAR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARYVAR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DICTIONARYVAR *) ((arg1)->DICTIONARYVAR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARYWDFLT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DICTIONARYWDFLT *arg2 = (Dwg_Object_DICTIONARYWDFLT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DICTIONARYWDFLT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARYWDFLT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DICTIONARYWDFLT_set" "', argument " "2"" of type '" "Dwg_Object_DICTIONARYWDFLT *""'"); 
  }
  arg2 = (Dwg_Object_DICTIONARYWDFLT *)(argp2);
  if (arg1) (arg1)->DICTIONARYWDFLT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DICTIONARYWDFLT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYWDFLT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DICTIONARYWDFLT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DICTIONARYWDFLT *) ((arg1)->DICTIONARYWDFLT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *arg2 = (Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set" "', argument " "2"" of type '" "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *""'"); 
  }
  arg2 = (Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *)(argp2);
  if (arg1) (arg1)->DYNAMICBLOCKPURGEPREVENTER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *) ((arg1)->DYNAMICBLOCKPURGEPREVENTER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FIELD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_FIELD *arg2 = (Dwg_Object_FIELD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_FIELD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FIELD_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_FIELD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_FIELD_set" "', argument " "2"" of type '" "Dwg_Object_FIELD *""'"); 
  }
  arg2 = (Dwg_Object_FIELD *)(argp2);
  if (arg1) (arg1)->FIELD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FIELD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FIELD_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_FIELD *) ((arg1)->FIELD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FIELDLIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_FIELDLIST *arg2 = (Dwg_Object_FIELDLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_FIELDLIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FIELDLIST_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_FIELDLIST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_FIELDLIST_set" "', argument " "2"" of type '" "Dwg_Object_FIELDLIST *""'"); 
  }
  arg2 = (Dwg_Object_FIELDLIST *)(argp2);
  if (arg1) (arg1)->FIELDLIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FIELDLIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELDLIST *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FIELDLIST_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_FIELDLIST *) ((arg1)->FIELDLIST);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GEODATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_GEODATA *arg2 = (Dwg_Object_GEODATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_GEODATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GEODATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_GEODATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_GEODATA_set" "', argument " "2"" of type '" "Dwg_Object_GEODATA *""'"); 
  }
  arg2 = (Dwg_Object_GEODATA *)(argp2);
  if (arg1) (arg1)->GEODATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GEODATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GEODATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GEODATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_GEODATA *) ((arg1)->GEODATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GROUP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_GROUP *arg2 = (Dwg_Object_GROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_GROUP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GROUP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_GROUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_GROUP_set" "', argument " "2"" of type '" "Dwg_Object_GROUP *""'"); 
  }
  arg2 = (Dwg_Object_GROUP *)(argp2);
  if (arg1) (arg1)->GROUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GROUP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GROUP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_GROUP *) ((arg1)->GROUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IDBUFFER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_IDBUFFER *arg2 = (Dwg_Object_IDBUFFER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_IDBUFFER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IDBUFFER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_IDBUFFER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_IDBUFFER_set" "', argument " "2"" of type '" "Dwg_Object_IDBUFFER *""'"); 
  }
  arg2 = (Dwg_Object_IDBUFFER *)(argp2);
  if (arg1) (arg1)->IDBUFFER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IDBUFFER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IDBUFFER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IDBUFFER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_IDBUFFER *) ((arg1)->IDBUFFER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGEDEF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_IMAGEDEF *arg2 = (Dwg_Object_IMAGEDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_IMAGEDEF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGEDEF_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_IMAGEDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_IMAGEDEF_set" "', argument " "2"" of type '" "Dwg_Object_IMAGEDEF *""'"); 
  }
  arg2 = (Dwg_Object_IMAGEDEF *)(argp2);
  if (arg1) (arg1)->IMAGEDEF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGEDEF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGEDEF_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_IMAGEDEF *) ((arg1)->IMAGEDEF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGEDEF_REACTOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_IMAGEDEF_REACTOR *arg2 = (Dwg_Object_IMAGEDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_IMAGEDEF_REACTOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGEDEF_REACTOR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_IMAGEDEF_REACTOR_set" "', argument " "2"" of type '" "Dwg_Object_IMAGEDEF_REACTOR *""'"); 
  }
  arg2 = (Dwg_Object_IMAGEDEF_REACTOR *)(argp2);
  if (arg1) (arg1)->IMAGEDEF_REACTOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGEDEF_REACTOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGEDEF_REACTOR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_IMAGEDEF_REACTOR *) ((arg1)->IMAGEDEF_REACTOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_INDEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_INDEX *arg2 = (Dwg_Object_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_INDEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_INDEX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_INDEX_set" "', argument " "2"" of type '" "Dwg_Object_INDEX *""'"); 
  }
  arg2 = (Dwg_Object_INDEX *)(argp2);
  if (arg1) (arg1)->INDEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_INDEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_INDEX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_INDEX *) ((arg1)->INDEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYERFILTER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LAYERFILTER *arg2 = (Dwg_Object_LAYERFILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LAYERFILTER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYERFILTER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYERFILTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LAYERFILTER_set" "', argument " "2"" of type '" "Dwg_Object_LAYERFILTER *""'"); 
  }
  arg2 = (Dwg_Object_LAYERFILTER *)(argp2);
  if (arg1) (arg1)->LAYERFILTER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYERFILTER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYERFILTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYERFILTER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LAYERFILTER *) ((arg1)->LAYERFILTER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_INDEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LAYER_INDEX *arg2 = (Dwg_Object_LAYER_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LAYER_INDEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_INDEX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYER_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LAYER_INDEX_set" "', argument " "2"" of type '" "Dwg_Object_LAYER_INDEX *""'"); 
  }
  arg2 = (Dwg_Object_LAYER_INDEX *)(argp2);
  if (arg1) (arg1)->LAYER_INDEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYER_INDEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYER_INDEX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LAYER_INDEX *) ((arg1)->LAYER_INDEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYOUT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LAYOUT *arg2 = (Dwg_Object_LAYOUT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LAYOUT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYOUT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LAYOUT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LAYOUT_set" "', argument " "2"" of type '" "Dwg_Object_LAYOUT *""'"); 
  }
  arg2 = (Dwg_Object_LAYOUT *)(argp2);
  if (arg1) (arg1)->LAYOUT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LAYOUT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYOUT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LAYOUT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LAYOUT *) ((arg1)->LAYOUT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PLACEHOLDER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PLACEHOLDER *arg2 = (Dwg_Object_PLACEHOLDER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PLACEHOLDER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PLACEHOLDER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PLACEHOLDER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PLACEHOLDER_set" "', argument " "2"" of type '" "Dwg_Object_PLACEHOLDER *""'"); 
  }
  arg2 = (Dwg_Object_PLACEHOLDER *)(argp2);
  if (arg1) (arg1)->PLACEHOLDER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PLACEHOLDER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLACEHOLDER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PLACEHOLDER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PLACEHOLDER *) ((arg1)->PLACEHOLDER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLACEHOLDER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PLOTSETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PLOTSETTINGS *arg2 = (Dwg_Object_PLOTSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PLOTSETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PLOTSETTINGS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PLOTSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PLOTSETTINGS_set" "', argument " "2"" of type '" "Dwg_Object_PLOTSETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_PLOTSETTINGS *)(argp2);
  if (arg1) (arg1)->PLOTSETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PLOTSETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLOTSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PLOTSETTINGS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PLOTSETTINGS *) ((arg1)->PLOTSETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RASTERVARIABLES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RASTERVARIABLES *arg2 = (Dwg_Object_RASTERVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RASTERVARIABLES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RASTERVARIABLES_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RASTERVARIABLES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RASTERVARIABLES_set" "', argument " "2"" of type '" "Dwg_Object_RASTERVARIABLES *""'"); 
  }
  arg2 = (Dwg_Object_RASTERVARIABLES *)(argp2);
  if (arg1) (arg1)->RASTERVARIABLES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RASTERVARIABLES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RASTERVARIABLES *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RASTERVARIABLES_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RASTERVARIABLES *) ((arg1)->RASTERVARIABLES);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERENVIRONMENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RENDERENVIRONMENT *arg2 = (Dwg_Object_RENDERENVIRONMENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RENDERENVIRONMENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERENVIRONMENT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RENDERENVIRONMENT_set" "', argument " "2"" of type '" "Dwg_Object_RENDERENVIRONMENT *""'"); 
  }
  arg2 = (Dwg_Object_RENDERENVIRONMENT *)(argp2);
  if (arg1) (arg1)->RENDERENVIRONMENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERENVIRONMENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENVIRONMENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERENVIRONMENT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RENDERENVIRONMENT *) ((arg1)->RENDERENVIRONMENT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SCALE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SCALE *arg2 = (Dwg_Object_SCALE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SCALE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SCALE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SCALE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SCALE_set" "', argument " "2"" of type '" "Dwg_Object_SCALE *""'"); 
  }
  arg2 = (Dwg_Object_SCALE *)(argp2);
  if (arg1) (arg1)->SCALE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SCALE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SCALE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SCALE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SCALE *) ((arg1)->SCALE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTIONVIEWSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SECTIONVIEWSTYLE *arg2 = (Dwg_Object_SECTIONVIEWSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SECTIONVIEWSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTIONVIEWSTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SECTIONVIEWSTYLE_set" "', argument " "2"" of type '" "Dwg_Object_SECTIONVIEWSTYLE *""'"); 
  }
  arg2 = (Dwg_Object_SECTIONVIEWSTYLE *)(argp2);
  if (arg1) (arg1)->SECTIONVIEWSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTIONVIEWSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTIONVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTIONVIEWSTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SECTIONVIEWSTYLE *) ((arg1)->SECTIONVIEWSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTION_MANAGER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SECTION_MANAGER *arg2 = (Dwg_Object_SECTION_MANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SECTION_MANAGER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTION_MANAGER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SECTION_MANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SECTION_MANAGER_set" "', argument " "2"" of type '" "Dwg_Object_SECTION_MANAGER *""'"); 
  }
  arg2 = (Dwg_Object_SECTION_MANAGER *)(argp2);
  if (arg1) (arg1)->SECTION_MANAGER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTION_MANAGER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_MANAGER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTION_MANAGER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SECTION_MANAGER *) ((arg1)->SECTION_MANAGER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SORTENTSTABLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SORTENTSTABLE *arg2 = (Dwg_Object_SORTENTSTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SORTENTSTABLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SORTENTSTABLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SORTENTSTABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SORTENTSTABLE_set" "', argument " "2"" of type '" "Dwg_Object_SORTENTSTABLE *""'"); 
  }
  arg2 = (Dwg_Object_SORTENTSTABLE *)(argp2);
  if (arg1) (arg1)->SORTENTSTABLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SORTENTSTABLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SORTENTSTABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SORTENTSTABLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SORTENTSTABLE *) ((arg1)->SORTENTSTABLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SPATIAL_FILTER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SPATIAL_FILTER *arg2 = (Dwg_Object_SPATIAL_FILTER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SPATIAL_FILTER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SPATIAL_FILTER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SPATIAL_FILTER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SPATIAL_FILTER_set" "', argument " "2"" of type '" "Dwg_Object_SPATIAL_FILTER *""'"); 
  }
  arg2 = (Dwg_Object_SPATIAL_FILTER *)(argp2);
  if (arg1) (arg1)->SPATIAL_FILTER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SPATIAL_FILTER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_FILTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SPATIAL_FILTER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SPATIAL_FILTER *) ((arg1)->SPATIAL_FILTER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SUN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SUN *arg2 = (Dwg_Object_SUN *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SUN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SUN_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SUN, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SUN_set" "', argument " "2"" of type '" "Dwg_Object_SUN *""'"); 
  }
  arg2 = (Dwg_Object_SUN *)(argp2);
  if (arg1) (arg1)->SUN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SUN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SUN *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SUN_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SUN *) ((arg1)->SUN);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLEGEOMETRY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_TABLEGEOMETRY *arg2 = (Dwg_Object_TABLEGEOMETRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_TABLEGEOMETRY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLEGEOMETRY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLEGEOMETRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_TABLEGEOMETRY_set" "', argument " "2"" of type '" "Dwg_Object_TABLEGEOMETRY *""'"); 
  }
  arg2 = (Dwg_Object_TABLEGEOMETRY *)(argp2);
  if (arg1) (arg1)->TABLEGEOMETRY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLEGEOMETRY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLEGEOMETRY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLEGEOMETRY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_TABLEGEOMETRY *) ((arg1)->TABLEGEOMETRY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VBA_PROJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VBA_PROJECT *arg2 = (Dwg_Object_VBA_PROJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VBA_PROJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VBA_PROJECT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VBA_PROJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VBA_PROJECT_set" "', argument " "2"" of type '" "Dwg_Object_VBA_PROJECT *""'"); 
  }
  arg2 = (Dwg_Object_VBA_PROJECT *)(argp2);
  if (arg1) (arg1)->VBA_PROJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VBA_PROJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VBA_PROJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VBA_PROJECT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VBA_PROJECT *) ((arg1)->VBA_PROJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VISUALSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_VISUALSTYLE *arg2 = (Dwg_Object_VISUALSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_VISUALSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VISUALSTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_VISUALSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_VISUALSTYLE_set" "', argument " "2"" of type '" "Dwg_Object_VISUALSTYLE *""'"); 
  }
  arg2 = (Dwg_Object_VISUALSTYLE *)(argp2);
  if (arg1) (arg1)->VISUALSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_VISUALSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VISUALSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_VISUALSTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_VISUALSTYLE *) ((arg1)->VISUALSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_WIPEOUTVARIABLES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_WIPEOUTVARIABLES *arg2 = (Dwg_Object_WIPEOUTVARIABLES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_WIPEOUTVARIABLES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_WIPEOUTVARIABLES_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_WIPEOUTVARIABLES_set" "', argument " "2"" of type '" "Dwg_Object_WIPEOUTVARIABLES *""'"); 
  }
  arg2 = (Dwg_Object_WIPEOUTVARIABLES *)(argp2);
  if (arg1) (arg1)->WIPEOUTVARIABLES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_WIPEOUTVARIABLES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_WIPEOUTVARIABLES *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_WIPEOUTVARIABLES_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_WIPEOUTVARIABLES *) ((arg1)->WIPEOUTVARIABLES);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_XRECORD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_XRECORD *arg2 = (Dwg_Object_XRECORD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_XRECORD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_XRECORD_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_XRECORD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_XRECORD_set" "', argument " "2"" of type '" "Dwg_Object_XRECORD *""'"); 
  }
  arg2 = (Dwg_Object_XRECORD *)(argp2);
  if (arg1) (arg1)->XRECORD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_XRECORD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_XRECORD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_XRECORD_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_XRECORD *) ((arg1)->XRECORD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PDFDEFINITION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PDFDEFINITION *arg2 = (Dwg_Object_PDFDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PDFDEFINITION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PDFDEFINITION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PDFDEFINITION_set" "', argument " "2"" of type '" "Dwg_Object_PDFDEFINITION *""'"); 
  }
  arg2 = (Dwg_Object_PDFDEFINITION *)(argp2);
  if (arg1) (arg1)->PDFDEFINITION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PDFDEFINITION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PDFDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PDFDEFINITION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PDFDEFINITION *) ((arg1)->PDFDEFINITION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DGNDEFINITION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DGNDEFINITION *arg2 = (Dwg_Object_DGNDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DGNDEFINITION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DGNDEFINITION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DGNDEFINITION_set" "', argument " "2"" of type '" "Dwg_Object_DGNDEFINITION *""'"); 
  }
  arg2 = (Dwg_Object_DGNDEFINITION *)(argp2);
  if (arg1) (arg1)->DGNDEFINITION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DGNDEFINITION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DGNDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DGNDEFINITION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DGNDEFINITION *) ((arg1)->DGNDEFINITION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DWFDEFINITION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DWFDEFINITION *arg2 = (Dwg_Object_DWFDEFINITION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DWFDEFINITION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DWFDEFINITION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DWFDEFINITION_set" "', argument " "2"" of type '" "Dwg_Object_DWFDEFINITION *""'"); 
  }
  arg2 = (Dwg_Object_DWFDEFINITION *)(argp2);
  if (arg1) (arg1)->DWFDEFINITION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DWFDEFINITION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DWFDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DWFDEFINITION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DWFDEFINITION *) ((arg1)->DWFDEFINITION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BREP_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_BREP_CLASS *arg2 = (Dwg_Object_ACSH_BREP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_BREP_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BREP_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_BREP_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_BREP_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_BREP_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_BREP_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_BREP_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BREP_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_BREP_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_BREP_CLASS *) ((arg1)->ACSH_BREP_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CHAMFER_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_CHAMFER_CLASS *arg2 = (Dwg_Object_ACSH_CHAMFER_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_CHAMFER_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_CHAMFER_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_CHAMFER_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_CHAMFER_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CHAMFER_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_CHAMFER_CLASS *) ((arg1)->ACSH_CHAMFER_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_PYRAMID_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_PYRAMID_CLASS *arg2 = (Dwg_Object_ACSH_PYRAMID_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_PYRAMID_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_PYRAMID_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_PYRAMID_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_PYRAMID_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_PYRAMID_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_PYRAMID_CLASS *) ((arg1)->ACSH_PYRAMID_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ALDIMOBJECTCONTEXTDATA *arg2 = (Dwg_Object_ALDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_ALDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_ALDIMOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->ALDIMOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ALDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ALDIMOBJECTCONTEXTDATA *) ((arg1)->ALDIMOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOC2DCONSTRAINTGROUP *arg2 = (Dwg_Object_ASSOC2DCONSTRAINTGROUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set" "', argument " "2"" of type '" "Dwg_Object_ASSOC2DCONSTRAINTGROUP *""'"); 
  }
  arg2 = (Dwg_Object_ASSOC2DCONSTRAINTGROUP *)(argp2);
  if (arg1) (arg1)->ASSOC2DCONSTRAINTGROUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOC2DCONSTRAINTGROUP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOC2DCONSTRAINTGROUP *) ((arg1)->ASSOC2DCONSTRAINTGROUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCACTION *arg2 = (Dwg_Object_ASSOCACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCACTION_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCACTION *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCACTION *)(argp2);
  if (arg1) (arg1)->ASSOCACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCACTION *) ((arg1)->ASSOCACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCACTIONPARAM *arg2 = (Dwg_Object_ASSOCACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCACTIONPARAM *) ((arg1)->ASSOCACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYACTIONBODY *arg2 = (Dwg_Object_ASSOCARRAYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYACTIONBODY *) ((arg1)->ASSOCARRAYACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCASMBODYACTIONPARAM *arg2 = (Dwg_Object_ASSOCASMBODYACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCASMBODYACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCASMBODYACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCASMBODYACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCASMBODYACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCASMBODYACTIONPARAM *) ((arg1)->ASSOCASMBODYACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCBLENDSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *) ((arg1)->ASSOCBLENDSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *arg2 = (Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCCOMPOUNDACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *) ((arg1)->ASSOCCOMPOUNDACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCDEPENDENCY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCDEPENDENCY *arg2 = (Dwg_Object_ASSOCDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCDEPENDENCY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCDEPENDENCY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCDEPENDENCY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCDEPENDENCY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCDEPENDENCY *)(argp2);
  if (arg1) (arg1)->ASSOCDEPENDENCY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCDEPENDENCY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCDEPENDENCY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCDEPENDENCY *) ((arg1)->ASSOCDEPENDENCY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCDIMDEPENDENCYBODY *arg2 = (Dwg_Object_ASSOCDIMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCDIMDEPENDENCYBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCDIMDEPENDENCYBODY *)(argp2);
  if (arg1) (arg1)->ASSOCDIMDEPENDENCYBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDIMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCDIMDEPENDENCYBODY *) ((arg1)->ASSOCDIMDEPENDENCYBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCEXTENDSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *) ((arg1)->ASSOCEXTENDSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCEXTRUDEDSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *) ((arg1)->ASSOCEXTRUDEDSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCFACEACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCFACEACTIONPARAM *arg2 = (Dwg_Object_ASSOCFACEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCFACEACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCFACEACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCFACEACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCFACEACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFACEACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCFACEACTIONPARAM *) ((arg1)->ASSOCFACEACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCFILLETSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *) ((arg1)->ASSOCFILLETSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCLOFTEDSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *) ((arg1)->ASSOCLOFTEDSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCNETWORKSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *) ((arg1)->ASSOCNETWORKSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCOBJECTACTIONPARAM *arg2 = (Dwg_Object_ASSOCOBJECTACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCOBJECTACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCOBJECTACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCOBJECTACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOBJECTACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCOBJECTACTIONPARAM *) ((arg1)->ASSOCOBJECTACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCOFFSETSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *) ((arg1)->ASSOCOFFSETSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *arg2 = (Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCOSNAPPOINTREFACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *) ((arg1)->ASSOCOSNAPPOINTREFACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCPATCHSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *) ((arg1)->ASSOCPATCHSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPATHACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCPATHACTIONPARAM *arg2 = (Dwg_Object_ASSOCPATHACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCPATHACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCPATHACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCPATHACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPATHACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATHACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCPATHACTIONPARAM *) ((arg1)->ASSOCPATHACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCPLANESURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCPLANESURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCPLANESURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCPLANESURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCPLANESURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPLANESURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCPLANESURFACEACTIONBODY *) ((arg1)->ASSOCPLANESURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCPOINTREFACTIONPARAM *arg2 = (Dwg_Object_ASSOCPOINTREFACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCPOINTREFACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCPOINTREFACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCPOINTREFACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCPOINTREFACTIONPARAM *) ((arg1)->ASSOCPOINTREFACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCREVOLVEDSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *) ((arg1)->ASSOCREVOLVEDSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCTRIMSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *) ((arg1)->ASSOCTRIMSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCVALUEDEPENDENCY *arg2 = (Dwg_Object_ASSOCVALUEDEPENDENCY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCVALUEDEPENDENCY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCVALUEDEPENDENCY *)(argp2);
  if (arg1) (arg1)->ASSOCVALUEDEPENDENCY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVALUEDEPENDENCY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVALUEDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCVALUEDEPENDENCY *) ((arg1)->ASSOCVALUEDEPENDENCY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVARIABLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCVARIABLE *arg2 = (Dwg_Object_ASSOCVARIABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCVARIABLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVARIABLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCVARIABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCVARIABLE_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCVARIABLE *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCVARIABLE *)(argp2);
  if (arg1) (arg1)->ASSOCVARIABLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVARIABLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVARIABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVARIABLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCVARIABLE *) ((arg1)->ASSOCVARIABLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCVERTEXACTIONPARAM *arg2 = (Dwg_Object_ASSOCVERTEXACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCVERTEXACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCVERTEXACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCVERTEXACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVERTEXACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCVERTEXACTIONPARAM *) ((arg1)->ASSOCVERTEXACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLKREFOBJECTCONTEXTDATA *arg2 = (Dwg_Object_BLKREFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_BLKREFOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_BLKREFOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->BLKREFOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLKREFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLKREFOBJECTCONTEXTDATA *) ((arg1)->BLKREFOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKALIGNEDCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *) ((arg1)->BLOCKALIGNEDCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKANGULARCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *) ((arg1)->BLOCKANGULARCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKARRAYACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKARRAYACTION *arg2 = (Dwg_Object_BLOCKARRAYACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKARRAYACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKARRAYACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKARRAYACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKARRAYACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKARRAYACTION *)(argp2);
  if (arg1) (arg1)->BLOCKARRAYACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKARRAYACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKARRAYACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKARRAYACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKARRAYACTION *) ((arg1)->BLOCKARRAYACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKDIAMETRICCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *) ((arg1)->BLOCKDIAMETRICCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKHORIZONTALCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *) ((arg1)->BLOCKHORIZONTALCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKLINEARCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *) ((arg1)->BLOCKLINEARCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLINEARPARAMETER *arg2 = (Dwg_Object_BLOCKLINEARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLINEARPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLINEARPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLINEARPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLINEARPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKLINEARPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLINEARPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLINEARPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLINEARPARAMETER *) ((arg1)->BLOCKLINEARPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLOOKUPACTION *arg2 = (Dwg_Object_BLOCKLOOKUPACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLOOKUPACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLOOKUPACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLOOKUPACTION *)(argp2);
  if (arg1) (arg1)->BLOCKLOOKUPACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPACTION *) ((arg1)->BLOCKLOOKUPACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKLOOKUPPARAMETER *arg2 = (Dwg_Object_BLOCKLOOKUPPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKLOOKUPPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKLOOKUPPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKLOOKUPPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKLOOKUPPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPPARAMETER *) ((arg1)->BLOCKLOOKUPPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPARAMDEPENDENCYBODY *arg2 = (Dwg_Object_BLOCKPARAMDEPENDENCYBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPARAMDEPENDENCYBODY *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPARAMDEPENDENCYBODY *)(argp2);
  if (arg1) (arg1)->BLOCKPARAMDEPENDENCYBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPARAMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPARAMDEPENDENCYBODY *) ((arg1)->BLOCKPARAMDEPENDENCYBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPOINTPARAMETER *arg2 = (Dwg_Object_BLOCKPOINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPOINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPOINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPOINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPOINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKPOINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPOINTPARAMETER *) ((arg1)->BLOCKPOINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPOLARGRIP *arg2 = (Dwg_Object_BLOCKPOLARGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPOLARGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPOLARGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPOLARGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPOLARGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKPOLARGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPOLARGRIP *) ((arg1)->BLOCKPOLARGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPOLARPARAMETER *arg2 = (Dwg_Object_BLOCKPOLARPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPOLARPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPOLARPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPOLARPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPOLARPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKPOLARPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPOLARPARAMETER *) ((arg1)->BLOCKPOLARPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPOLARSTRETCHACTION *arg2 = (Dwg_Object_BLOCKPOLARSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPOLARSTRETCHACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPOLARSTRETCHACTION *)(argp2);
  if (arg1) (arg1)->BLOCKPOLARSTRETCHACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPOLARSTRETCHACTION *) ((arg1)->BLOCKPOLARSTRETCHACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKRADIALCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *) ((arg1)->BLOCKRADIALCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKREPRESENTATION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKREPRESENTATION *arg2 = (Dwg_Object_BLOCKREPRESENTATION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKREPRESENTATION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKREPRESENTATION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKREPRESENTATION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKREPRESENTATION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKREPRESENTATION *)(argp2);
  if (arg1) (arg1)->BLOCKREPRESENTATION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKREPRESENTATION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKREPRESENTATION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKREPRESENTATION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKREPRESENTATION *) ((arg1)->BLOCKREPRESENTATION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATIONPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKROTATIONPARAMETER *arg2 = (Dwg_Object_BLOCKROTATIONPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKROTATIONPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKROTATIONPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKROTATIONPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKROTATIONPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONPARAMETER *) ((arg1)->BLOCKROTATIONPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKSTRETCHACTION_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKSTRETCHACTION *arg2 = (Dwg_Object_BLOCKSTRETCHACTION *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKSTRETCHACTION_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKSTRETCHACTION_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKSTRETCHACTION_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKSTRETCHACTION *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKSTRETCHACTION *)(argp2);
  if (arg1) (arg1)->BLOCKSTRETCHACTION = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKSTRETCHACTION_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKSTRETCHACTION_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKSTRETCHACTION *) ((arg1)->BLOCKSTRETCHACTION);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKUSERPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKUSERPARAMETER *arg2 = (Dwg_Object_BLOCKUSERPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKUSERPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKUSERPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKUSERPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKUSERPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKUSERPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKUSERPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKUSERPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKUSERPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKUSERPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKUSERPARAMETER *) ((arg1)->BLOCKUSERPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *arg2 = (Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKVERTICALCONSTRAINTPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *) ((arg1)->BLOCKVERTICALCONSTRAINTPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKVISIBILITYPARAMETER *arg2 = (Dwg_Object_BLOCKVISIBILITYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKVISIBILITYPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKVISIBILITYPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKVISIBILITYPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYPARAMETER *) ((arg1)->BLOCKVISIBILITYPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKXYGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKXYGRIP *arg2 = (Dwg_Object_BLOCKXYGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKXYGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKXYGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKXYGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKXYGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKXYGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKXYGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKXYGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKXYGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKXYGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKXYGRIP *) ((arg1)->BLOCKXYGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKXYPARAMETER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKXYPARAMETER *arg2 = (Dwg_Object_BLOCKXYPARAMETER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKXYPARAMETER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKXYPARAMETER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKXYPARAMETER_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKXYPARAMETER *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKXYPARAMETER *)(argp2);
  if (arg1) (arg1)->BLOCKXYPARAMETER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKXYPARAMETER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKXYPARAMETER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKXYPARAMETER *) ((arg1)->BLOCKXYPARAMETER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DATALINK_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DATALINK *arg2 = (Dwg_Object_DATALINK *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DATALINK_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DATALINK_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DATALINK, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DATALINK_set" "', argument " "2"" of type '" "Dwg_Object_DATALINK *""'"); 
  }
  arg2 = (Dwg_Object_DATALINK *)(argp2);
  if (arg1) (arg1)->DATALINK = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DATALINK_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DATALINK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DATALINK_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DATALINK *) ((arg1)->DATALINK);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DBCOLOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DBCOLOR *arg2 = (Dwg_Object_DBCOLOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DBCOLOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DBCOLOR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DBCOLOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DBCOLOR_set" "', argument " "2"" of type '" "Dwg_Object_DBCOLOR *""'"); 
  }
  arg2 = (Dwg_Object_DBCOLOR *)(argp2);
  if (arg1) (arg1)->DBCOLOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DBCOLOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DBCOLOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DBCOLOR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DBCOLOR *) ((arg1)->DBCOLOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_EVALUATION_GRAPH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_EVALUATION_GRAPH *arg2 = (Dwg_Object_EVALUATION_GRAPH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_EVALUATION_GRAPH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_EVALUATION_GRAPH_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_EVALUATION_GRAPH_set" "', argument " "2"" of type '" "Dwg_Object_EVALUATION_GRAPH *""'"); 
  }
  arg2 = (Dwg_Object_EVALUATION_GRAPH *)(argp2);
  if (arg1) (arg1)->EVALUATION_GRAPH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_EVALUATION_GRAPH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_EVALUATION_GRAPH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_EVALUATION_GRAPH_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_EVALUATION_GRAPH *) ((arg1)->EVALUATION_GRAPH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_FCFOBJECTCONTEXTDATA *arg2 = (Dwg_Object_FCFOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_FCFOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_FCFOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->FCFOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_FCFOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FCFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_FCFOBJECTCONTEXTDATA *) ((arg1)->FCFOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GRADIENT_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_GRADIENT_BACKGROUND *arg2 = (Dwg_Object_GRADIENT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_GRADIENT_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GRADIENT_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_GRADIENT_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_GRADIENT_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_GRADIENT_BACKGROUND *)(argp2);
  if (arg1) (arg1)->GRADIENT_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GRADIENT_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GRADIENT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GRADIENT_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_GRADIENT_BACKGROUND *) ((arg1)->GRADIENT_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_GROUND_PLANE_BACKGROUND *arg2 = (Dwg_Object_GROUND_PLANE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_GROUND_PLANE_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_GROUND_PLANE_BACKGROUND *)(argp2);
  if (arg1) (arg1)->GROUND_PLANE_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GROUND_PLANE_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUND_PLANE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_GROUND_PLANE_BACKGROUND *) ((arg1)->GROUND_PLANE_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IBL_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_IBL_BACKGROUND *arg2 = (Dwg_Object_IBL_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_IBL_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IBL_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_IBL_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_IBL_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_IBL_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_IBL_BACKGROUND *)(argp2);
  if (arg1) (arg1)->IBL_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IBL_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IBL_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IBL_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_IBL_BACKGROUND *) ((arg1)->IBL_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGE_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_IMAGE_BACKGROUND *arg2 = (Dwg_Object_IMAGE_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_IMAGE_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGE_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_IMAGE_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_IMAGE_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_IMAGE_BACKGROUND *)(argp2);
  if (arg1) (arg1)->IMAGE_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_IMAGE_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_IMAGE_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_IMAGE_BACKGROUND *) ((arg1)->IMAGE_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LEADEROBJECTCONTEXTDATA *arg2 = (Dwg_Object_LEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_LEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_LEADEROBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->LEADEROBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LEADEROBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LEADEROBJECTCONTEXTDATA *) ((arg1)->LEADEROBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LIGHTLIST_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_LIGHTLIST *arg2 = (Dwg_Object_LIGHTLIST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_LIGHTLIST_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LIGHTLIST_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_LIGHTLIST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_LIGHTLIST_set" "', argument " "2"" of type '" "Dwg_Object_LIGHTLIST *""'"); 
  }
  arg2 = (Dwg_Object_LIGHTLIST *)(argp2);
  if (arg1) (arg1)->LIGHTLIST = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_LIGHTLIST_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LIGHTLIST *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_LIGHTLIST_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_LIGHTLIST *) ((arg1)->LIGHTLIST);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MATERIAL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MATERIAL *arg2 = (Dwg_Object_MATERIAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MATERIAL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MATERIAL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MATERIAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MATERIAL_set" "', argument " "2"" of type '" "Dwg_Object_MATERIAL *""'"); 
  }
  arg2 = (Dwg_Object_MATERIAL *)(argp2);
  if (arg1) (arg1)->MATERIAL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MATERIAL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MATERIAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MATERIAL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MATERIAL *) ((arg1)->MATERIAL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MENTALRAYRENDERSETTINGS *arg2 = (Dwg_Object_MENTALRAYRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set" "', argument " "2"" of type '" "Dwg_Object_MENTALRAYRENDERSETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_MENTALRAYRENDERSETTINGS *)(argp2);
  if (arg1) (arg1)->MENTALRAYRENDERSETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MENTALRAYRENDERSETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MENTALRAYRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MENTALRAYRENDERSETTINGS *) ((arg1)->MENTALRAYRENDERSETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLEADERSTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MLEADERSTYLE *arg2 = (Dwg_Object_MLEADERSTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MLEADERSTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLEADERSTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MLEADERSTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MLEADERSTYLE_set" "', argument " "2"" of type '" "Dwg_Object_MLEADERSTYLE *""'"); 
  }
  arg2 = (Dwg_Object_MLEADERSTYLE *)(argp2);
  if (arg1) (arg1)->MLEADERSTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLEADERSTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLEADERSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLEADERSTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MLEADERSTYLE *) ((arg1)->MLEADERSTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MTEXTOBJECTCONTEXTDATA *arg2 = (Dwg_Object_MTEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_MTEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_MTEXTOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->MTEXTOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MTEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MTEXTOBJECTCONTEXTDATA *) ((arg1)->MTEXTOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_OBJECT_PTR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_OBJECT_PTR *arg2 = (Dwg_Object_OBJECT_PTR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_OBJECT_PTR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_OBJECT_PTR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_OBJECT_PTR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_OBJECT_PTR_set" "', argument " "2"" of type '" "Dwg_Object_OBJECT_PTR *""'"); 
  }
  arg2 = (Dwg_Object_OBJECT_PTR *)(argp2);
  if (arg1) (arg1)->OBJECT_PTR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_OBJECT_PTR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_OBJECT_PTR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_OBJECT_PTR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_OBJECT_PTR *) ((arg1)->OBJECT_PTR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_OBJECT_PTR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PARTIAL_VIEWING_INDEX *arg2 = (Dwg_Object_PARTIAL_VIEWING_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set" "', argument " "2"" of type '" "Dwg_Object_PARTIAL_VIEWING_INDEX *""'"); 
  }
  arg2 = (Dwg_Object_PARTIAL_VIEWING_INDEX *)(argp2);
  if (arg1) (arg1)->PARTIAL_VIEWING_INDEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PARTIAL_VIEWING_INDEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PARTIAL_VIEWING_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PARTIAL_VIEWING_INDEX *) ((arg1)->PARTIAL_VIEWING_INDEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDCOLORMAP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTCLOUDCOLORMAP *arg2 = (Dwg_Object_POINTCLOUDCOLORMAP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTCLOUDCOLORMAP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDCOLORMAP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTCLOUDCOLORMAP_set" "', argument " "2"" of type '" "Dwg_Object_POINTCLOUDCOLORMAP *""'"); 
  }
  arg2 = (Dwg_Object_POINTCLOUDCOLORMAP *)(argp2);
  if (arg1) (arg1)->POINTCLOUDCOLORMAP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDCOLORMAP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDCOLORMAP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDCOLORMAP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTCLOUDCOLORMAP *) ((arg1)->POINTCLOUDCOLORMAP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTCLOUDDEF *arg2 = (Dwg_Object_POINTCLOUDDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTCLOUDDEF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_set" "', argument " "2"" of type '" "Dwg_Object_POINTCLOUDDEF *""'"); 
  }
  arg2 = (Dwg_Object_POINTCLOUDDEF *)(argp2);
  if (arg1) (arg1)->POINTCLOUDDEF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF *) ((arg1)->POINTCLOUDDEF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEFEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTCLOUDDEFEX *arg2 = (Dwg_Object_POINTCLOUDDEFEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTCLOUDDEFEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEFEX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTCLOUDDEFEX_set" "', argument " "2"" of type '" "Dwg_Object_POINTCLOUDDEFEX *""'"); 
  }
  arg2 = (Dwg_Object_POINTCLOUDDEFEX *)(argp2);
  if (arg1) (arg1)->POINTCLOUDDEFEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEFEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEFEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEFEX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEFEX *) ((arg1)->POINTCLOUDDEFEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTCLOUDDEF_REACTOR *arg2 = (Dwg_Object_POINTCLOUDDEF_REACTOR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set" "', argument " "2"" of type '" "Dwg_Object_POINTCLOUDDEF_REACTOR *""'"); 
  }
  arg2 = (Dwg_Object_POINTCLOUDDEF_REACTOR *)(argp2);
  if (arg1) (arg1)->POINTCLOUDDEF_REACTOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR *) ((arg1)->POINTCLOUDDEF_REACTOR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTCLOUDDEF_REACTOR_EX *arg2 = (Dwg_Object_POINTCLOUDDEF_REACTOR_EX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set" "', argument " "2"" of type '" "Dwg_Object_POINTCLOUDDEF_REACTOR_EX *""'"); 
  }
  arg2 = (Dwg_Object_POINTCLOUDDEF_REACTOR_EX *)(argp2);
  if (arg1) (arg1)->POINTCLOUDDEF_REACTOR_EX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR_EX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR_EX *) ((arg1)->POINTCLOUDDEF_REACTOR_EX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PROXY_OBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PROXY_OBJECT *arg2 = (Dwg_Object_PROXY_OBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PROXY_OBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PROXY_OBJECT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PROXY_OBJECT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PROXY_OBJECT_set" "', argument " "2"" of type '" "Dwg_Object_PROXY_OBJECT *""'"); 
  }
  arg2 = (Dwg_Object_PROXY_OBJECT *)(argp2);
  if (arg1) (arg1)->PROXY_OBJECT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PROXY_OBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PROXY_OBJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PROXY_OBJECT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PROXY_OBJECT *) ((arg1)->PROXY_OBJECT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RAPIDRTRENDERSETTINGS *arg2 = (Dwg_Object_RAPIDRTRENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set" "', argument " "2"" of type '" "Dwg_Object_RAPIDRTRENDERSETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_RAPIDRTRENDERSETTINGS *)(argp2);
  if (arg1) (arg1)->RAPIDRTRENDERSETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RAPIDRTRENDERSETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RAPIDRTRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RAPIDRTRENDERSETTINGS *) ((arg1)->RAPIDRTRENDERSETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERENTRY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RENDERENTRY *arg2 = (Dwg_Object_RENDERENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RENDERENTRY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERENTRY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RENDERENTRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RENDERENTRY_set" "', argument " "2"" of type '" "Dwg_Object_RENDERENTRY *""'"); 
  }
  arg2 = (Dwg_Object_RENDERENTRY *)(argp2);
  if (arg1) (arg1)->RENDERENTRY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERENTRY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENTRY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERENTRY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RENDERENTRY *) ((arg1)->RENDERENTRY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERGLOBAL_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RENDERGLOBAL *arg2 = (Dwg_Object_RENDERGLOBAL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RENDERGLOBAL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERGLOBAL_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RENDERGLOBAL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RENDERGLOBAL_set" "', argument " "2"" of type '" "Dwg_Object_RENDERGLOBAL *""'"); 
  }
  arg2 = (Dwg_Object_RENDERGLOBAL *)(argp2);
  if (arg1) (arg1)->RENDERGLOBAL = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERGLOBAL_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERGLOBAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERGLOBAL_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RENDERGLOBAL *) ((arg1)->RENDERGLOBAL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERSETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RENDERSETTINGS *arg2 = (Dwg_Object_RENDERSETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RENDERSETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERSETTINGS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RENDERSETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RENDERSETTINGS_set" "', argument " "2"" of type '" "Dwg_Object_RENDERSETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_RENDERSETTINGS *)(argp2);
  if (arg1) (arg1)->RENDERSETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RENDERSETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RENDERSETTINGS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RENDERSETTINGS *) ((arg1)->RENDERSETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTION_SETTINGS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SECTION_SETTINGS *arg2 = (Dwg_Object_SECTION_SETTINGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SECTION_SETTINGS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTION_SETTINGS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SECTION_SETTINGS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SECTION_SETTINGS_set" "', argument " "2"" of type '" "Dwg_Object_SECTION_SETTINGS *""'"); 
  }
  arg2 = (Dwg_Object_SECTION_SETTINGS *)(argp2);
  if (arg1) (arg1)->SECTION_SETTINGS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SECTION_SETTINGS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_SETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SECTION_SETTINGS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SECTION_SETTINGS *) ((arg1)->SECTION_SETTINGS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SKYLIGHT_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SKYLIGHT_BACKGROUND *arg2 = (Dwg_Object_SKYLIGHT_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_SKYLIGHT_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_SKYLIGHT_BACKGROUND *)(argp2);
  if (arg1) (arg1)->SKYLIGHT_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SKYLIGHT_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SKYLIGHT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SKYLIGHT_BACKGROUND *) ((arg1)->SKYLIGHT_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SOLID_BACKGROUND_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SOLID_BACKGROUND *arg2 = (Dwg_Object_SOLID_BACKGROUND *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SOLID_BACKGROUND_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SOLID_BACKGROUND_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SOLID_BACKGROUND_set" "', argument " "2"" of type '" "Dwg_Object_SOLID_BACKGROUND *""'"); 
  }
  arg2 = (Dwg_Object_SOLID_BACKGROUND *)(argp2);
  if (arg1) (arg1)->SOLID_BACKGROUND = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SOLID_BACKGROUND_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SOLID_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SOLID_BACKGROUND_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SOLID_BACKGROUND *) ((arg1)->SOLID_BACKGROUND);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SPATIAL_INDEX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SPATIAL_INDEX *arg2 = (Dwg_Object_SPATIAL_INDEX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SPATIAL_INDEX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SPATIAL_INDEX_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SPATIAL_INDEX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SPATIAL_INDEX_set" "', argument " "2"" of type '" "Dwg_Object_SPATIAL_INDEX *""'"); 
  }
  arg2 = (Dwg_Object_SPATIAL_INDEX *)(argp2);
  if (arg1) (arg1)->SPATIAL_INDEX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SPATIAL_INDEX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SPATIAL_INDEX_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SPATIAL_INDEX *) ((arg1)->SPATIAL_INDEX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLESTYLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_TABLESTYLE *arg2 = (Dwg_Object_TABLESTYLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_TABLESTYLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLESTYLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLESTYLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_TABLESTYLE_set" "', argument " "2"" of type '" "Dwg_Object_TABLESTYLE *""'"); 
  }
  arg2 = (Dwg_Object_TABLESTYLE *)(argp2);
  if (arg1) (arg1)->TABLESTYLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLESTYLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLESTYLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_TABLESTYLE *) ((arg1)->TABLESTYLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_TEXTOBJECTCONTEXTDATA *arg2 = (Dwg_Object_TEXTOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_TEXTOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_TEXTOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->TEXTOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_TEXTOBJECTCONTEXTDATA *) ((arg1)->TEXTOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *arg2 = (Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYMODIFYPARAMETERS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *) ((arg1)->ASSOCARRAYMODIFYPARAMETERS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYPATHPARAMETERS *arg2 = (Dwg_Object_ASSOCARRAYPATHPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYPATHPARAMETERS *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYPATHPARAMETERS *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYPATHPARAMETERS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPATHPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPATHPARAMETERS *) ((arg1)->ASSOCARRAYPATHPARAMETERS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYPOLARPARAMETERS *arg2 = (Dwg_Object_ASSOCARRAYPOLARPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYPOLARPARAMETERS *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYPOLARPARAMETERS *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYPOLARPARAMETERS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPOLARPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPOLARPARAMETERS *) ((arg1)->ASSOCARRAYPOLARPARAMETERS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *arg2 = (Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYRECTANGULARPARAMETERS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *) ((arg1)->ASSOCARRAYRECTANGULARPARAMETERS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMECOMMANDHISTORY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACMECOMMANDHISTORY *arg2 = (Dwg_Object_ACMECOMMANDHISTORY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACMECOMMANDHISTORY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMECOMMANDHISTORY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACMECOMMANDHISTORY_set" "', argument " "2"" of type '" "Dwg_Object_ACMECOMMANDHISTORY *""'"); 
  }
  arg2 = (Dwg_Object_ACMECOMMANDHISTORY *)(argp2);
  if (arg1) (arg1)->ACMECOMMANDHISTORY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMECOMMANDHISTORY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACMECOMMANDHISTORY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMECOMMANDHISTORY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACMECOMMANDHISTORY *) ((arg1)->ACMECOMMANDHISTORY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMECOMMANDHISTORY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMESCOPE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACMESCOPE *arg2 = (Dwg_Object_ACMESCOPE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACMESCOPE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMESCOPE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACMESCOPE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACMESCOPE_set" "', argument " "2"" of type '" "Dwg_Object_ACMESCOPE *""'"); 
  }
  arg2 = (Dwg_Object_ACMESCOPE *)(argp2);
  if (arg1) (arg1)->ACMESCOPE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMESCOPE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACMESCOPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMESCOPE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACMESCOPE *) ((arg1)->ACMESCOPE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMESCOPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMESTATEMGR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACMESTATEMGR *arg2 = (Dwg_Object_ACMESTATEMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACMESTATEMGR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMESTATEMGR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACMESTATEMGR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACMESTATEMGR_set" "', argument " "2"" of type '" "Dwg_Object_ACMESTATEMGR *""'"); 
  }
  arg2 = (Dwg_Object_ACMESTATEMGR *)(argp2);
  if (arg1) (arg1)->ACMESTATEMGR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACMESTATEMGR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACMESTATEMGR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACMESTATEMGR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACMESTATEMGR *) ((arg1)->ACMESTATEMGR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACMESTATEMGR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_EXTRUSION_CLASS *arg2 = (Dwg_Object_ACSH_EXTRUSION_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_EXTRUSION_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_EXTRUSION_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_EXTRUSION_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_EXTRUSION_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_EXTRUSION_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_EXTRUSION_CLASS *) ((arg1)->ACSH_EXTRUSION_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_EXTRUSION_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_LOFT_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_LOFT_CLASS *arg2 = (Dwg_Object_ACSH_LOFT_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_LOFT_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_LOFT_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_LOFT_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_LOFT_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_LOFT_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_LOFT_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_LOFT_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_LOFT_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_LOFT_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_LOFT_CLASS *) ((arg1)->ACSH_LOFT_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_LOFT_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_REVOLVE_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_REVOLVE_CLASS *arg2 = (Dwg_Object_ACSH_REVOLVE_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_REVOLVE_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_REVOLVE_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_REVOLVE_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_REVOLVE_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_REVOLVE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_REVOLVE_CLASS *) ((arg1)->ACSH_REVOLVE_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_REVOLVE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_SWEEP_CLASS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ACSH_SWEEP_CLASS *arg2 = (Dwg_Object_ACSH_SWEEP_CLASS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ACSH_SWEEP_CLASS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_SWEEP_CLASS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ACSH_SWEEP_CLASS_set" "', argument " "2"" of type '" "Dwg_Object_ACSH_SWEEP_CLASS *""'"); 
  }
  arg2 = (Dwg_Object_ACSH_SWEEP_CLASS *)(argp2);
  if (arg1) (arg1)->ACSH_SWEEP_CLASS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ACSH_SWEEP_CLASS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_SWEEP_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ACSH_SWEEP_CLASS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ACSH_SWEEP_CLASS *) ((arg1)->ACSH_SWEEP_CLASS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_SWEEP_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ANGDIMOBJECTCONTEXTDATA *arg2 = (Dwg_Object_ANGDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_ANGDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_ANGDIMOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->ANGDIMOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ANGDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ANGDIMOBJECTCONTEXTDATA *) ((arg1)->ANGDIMOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *arg2 = (Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->ANNOTSCALEOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *) ((arg1)->ANNOTSCALEOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *arg2 = (Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOC3POINTANGULARDIMACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *) ((arg1)->ASSOC3POINTANGULARDIMACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *arg2 = (Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCALIGNEDDIMACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *) ((arg1)->ASSOCALIGNEDDIMACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *arg2 = (Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCARRAYMODIFYACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *) ((arg1)->ASSOCARRAYMODIFYACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCEDGEACTIONPARAM *arg2 = (Dwg_Object_ASSOCEDGEACTIONPARAM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCEDGEACTIONPARAM *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCEDGEACTIONPARAM *)(argp2);
  if (arg1) (arg1)->ASSOCEDGEACTIONPARAM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGEACTIONPARAM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEDGEACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCEDGEACTIONPARAM *) ((arg1)->ASSOCEDGEACTIONPARAM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGEACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *arg2 = (Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCEDGECHAMFERACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *) ((arg1)->ASSOCEDGECHAMFERACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCEDGEFILLETACTIONBODY *arg2 = (Dwg_Object_ASSOCEDGEFILLETACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCEDGEFILLETACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCEDGEFILLETACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCEDGEFILLETACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEDGEFILLETACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCEDGEFILLETACTIONBODY *) ((arg1)->ASSOCEDGEFILLETACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCMLEADERACTIONBODY *arg2 = (Dwg_Object_ASSOCMLEADERACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCMLEADERACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCMLEADERACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCMLEADERACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCMLEADERACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCMLEADERACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCMLEADERACTIONBODY *) ((arg1)->ASSOCMLEADERACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCMLEADERACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCORDINATEDIMACTIONBODY *arg2 = (Dwg_Object_ASSOCORDINATEDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCORDINATEDIMACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCORDINATEDIMACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCORDINATEDIMACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCORDINATEDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCORDINATEDIMACTIONBODY *) ((arg1)->ASSOCORDINATEDIMACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCPERSSUBENTMANAGER *arg2 = (Dwg_Object_ASSOCPERSSUBENTMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCPERSSUBENTMANAGER *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCPERSSUBENTMANAGER *)(argp2);
  if (arg1) (arg1)->ASSOCPERSSUBENTMANAGER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPERSSUBENTMANAGER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCPERSSUBENTMANAGER *) ((arg1)->ASSOCPERSSUBENTMANAGER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPERSSUBENTMANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *arg2 = (Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCRESTOREENTITYSTATEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *) ((arg1)->ASSOCRESTOREENTITYSTATEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCROTATEDDIMACTIONBODY *arg2 = (Dwg_Object_ASSOCROTATEDDIMACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCROTATEDDIMACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCROTATEDDIMACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCROTATEDDIMACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCROTATEDDIMACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCROTATEDDIMACTIONBODY *) ((arg1)->ASSOCROTATEDDIMACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *arg2 = (Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set" "', argument " "2"" of type '" "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *""'"); 
  }
  arg2 = (Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *)(argp2);
  if (arg1) (arg1)->ASSOCSWEPTSURFACEACTIONBODY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *) ((arg1)->ASSOCSWEPTSURFACEACTIONBODY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPROPERTIESTABLE *arg2 = (Dwg_Object_BLOCKPROPERTIESTABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPROPERTIESTABLE *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPROPERTIESTABLE *)(argp2);
  if (arg1) (arg1)->BLOCKPROPERTIESTABLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPROPERTIESTABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPROPERTIESTABLE *) ((arg1)->BLOCKPROPERTIESTABLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BLOCKPROPERTIESTABLEGRIP *arg2 = (Dwg_Object_BLOCKPROPERTIESTABLEGRIP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set" "', argument " "2"" of type '" "Dwg_Object_BLOCKPROPERTIESTABLEGRIP *""'"); 
  }
  arg2 = (Dwg_Object_BLOCKPROPERTIESTABLEGRIP *)(argp2);
  if (arg1) (arg1)->BLOCKPROPERTIESTABLEGRIP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPROPERTIESTABLEGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BLOCKPROPERTIESTABLEGRIP *) ((arg1)->BLOCKPROPERTIESTABLEGRIP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BREAKDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BREAKDATA *arg2 = (Dwg_Object_BREAKDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BREAKDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BREAKDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BREAKDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BREAKDATA_set" "', argument " "2"" of type '" "Dwg_Object_BREAKDATA *""'"); 
  }
  arg2 = (Dwg_Object_BREAKDATA *)(argp2);
  if (arg1) (arg1)->BREAKDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BREAKDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BREAKDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BREAKDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BREAKDATA *) ((arg1)->BREAKDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BREAKDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BREAKPOINTREF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_BREAKPOINTREF *arg2 = (Dwg_Object_BREAKPOINTREF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_BREAKPOINTREF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BREAKPOINTREF_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BREAKPOINTREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_BREAKPOINTREF_set" "', argument " "2"" of type '" "Dwg_Object_BREAKPOINTREF *""'"); 
  }
  arg2 = (Dwg_Object_BREAKPOINTREF *)(argp2);
  if (arg1) (arg1)->BREAKPOINTREF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_BREAKPOINTREF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BREAKPOINTREF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_BREAKPOINTREF_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_BREAKPOINTREF *) ((arg1)->BREAKPOINTREF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BREAKPOINTREF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CONTEXTDATAMANAGER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_CONTEXTDATAMANAGER *arg2 = (Dwg_Object_CONTEXTDATAMANAGER *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_CONTEXTDATAMANAGER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CONTEXTDATAMANAGER_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_CONTEXTDATAMANAGER_set" "', argument " "2"" of type '" "Dwg_Object_CONTEXTDATAMANAGER *""'"); 
  }
  arg2 = (Dwg_Object_CONTEXTDATAMANAGER *)(argp2);
  if (arg1) (arg1)->CONTEXTDATAMANAGER = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CONTEXTDATAMANAGER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CONTEXTDATAMANAGER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CONTEXTDATAMANAGER_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_CONTEXTDATAMANAGER *) ((arg1)->CONTEXTDATAMANAGER);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CONTEXTDATAMANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CSACDOCUMENTOPTIONS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_CSACDOCUMENTOPTIONS *arg2 = (Dwg_Object_CSACDOCUMENTOPTIONS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_set" "', argument " "2"" of type '" "Dwg_Object_CSACDOCUMENTOPTIONS *""'"); 
  }
  arg2 = (Dwg_Object_CSACDOCUMENTOPTIONS *)(argp2);
  if (arg1) (arg1)->CSACDOCUMENTOPTIONS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CSACDOCUMENTOPTIONS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CSACDOCUMENTOPTIONS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_CSACDOCUMENTOPTIONS *) ((arg1)->CSACDOCUMENTOPTIONS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CSACDOCUMENTOPTIONS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CURVEPATH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_CURVEPATH *arg2 = (Dwg_Object_CURVEPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_CURVEPATH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CURVEPATH_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_CURVEPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_CURVEPATH_set" "', argument " "2"" of type '" "Dwg_Object_CURVEPATH *""'"); 
  }
  arg2 = (Dwg_Object_CURVEPATH *)(argp2);
  if (arg1) (arg1)->CURVEPATH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_CURVEPATH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CURVEPATH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_CURVEPATH_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_CURVEPATH *) ((arg1)->CURVEPATH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CURVEPATH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DATATABLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DATATABLE *arg2 = (Dwg_Object_DATATABLE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DATATABLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DATATABLE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DATATABLE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DATATABLE_set" "', argument " "2"" of type '" "Dwg_Object_DATATABLE *""'"); 
  }
  arg2 = (Dwg_Object_DATATABLE *)(argp2);
  if (arg1) (arg1)->DATATABLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DATATABLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DATATABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DATATABLE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DATATABLE *) ((arg1)->DATATABLE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATATABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMASSOC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DIMASSOC *arg2 = (Dwg_Object_DIMASSOC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DIMASSOC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMASSOC_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DIMASSOC, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DIMASSOC_set" "', argument " "2"" of type '" "Dwg_Object_DIMASSOC *""'"); 
  }
  arg2 = (Dwg_Object_DIMASSOC *)(argp2);
  if (arg1) (arg1)->DIMASSOC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DIMASSOC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMASSOC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DIMASSOC_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DIMASSOC *) ((arg1)->DIMASSOC);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMASSOC, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DMDIMOBJECTCONTEXTDATA *arg2 = (Dwg_Object_DMDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_DMDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_DMDIMOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->DMDIMOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DMDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DMDIMOBJECTCONTEXTDATA *) ((arg1)->DMDIMOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_DYNAMICBLOCKPROXYNODE *arg2 = (Dwg_Object_DYNAMICBLOCKPROXYNODE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set" "', argument " "2"" of type '" "Dwg_Object_DYNAMICBLOCKPROXYNODE *""'"); 
  }
  arg2 = (Dwg_Object_DYNAMICBLOCKPROXYNODE *)(argp2);
  if (arg1) (arg1)->DYNAMICBLOCKPROXYNODE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DYNAMICBLOCKPROXYNODE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_DYNAMICBLOCKPROXYNODE *) ((arg1)->DYNAMICBLOCKPROXYNODE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DYNAMICBLOCKPROXYNODE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GEOMAPIMAGE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_GEOMAPIMAGE *arg2 = (Dwg_Object_GEOMAPIMAGE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_GEOMAPIMAGE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GEOMAPIMAGE_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_GEOMAPIMAGE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_GEOMAPIMAGE_set" "', argument " "2"" of type '" "Dwg_Object_GEOMAPIMAGE *""'"); 
  }
  arg2 = (Dwg_Object_GEOMAPIMAGE *)(argp2);
  if (arg1) (arg1)->GEOMAPIMAGE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_GEOMAPIMAGE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GEOMAPIMAGE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_GEOMAPIMAGE_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_GEOMAPIMAGE *) ((arg1)->GEOMAPIMAGE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GEOMAPIMAGE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MLEADEROBJECTCONTEXTDATA *arg2 = (Dwg_Object_MLEADEROBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_MLEADEROBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_MLEADEROBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->MLEADEROBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLEADEROBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MLEADEROBJECTCONTEXTDATA *) ((arg1)->MLEADEROBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MOTIONPATH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MOTIONPATH *arg2 = (Dwg_Object_MOTIONPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MOTIONPATH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MOTIONPATH_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MOTIONPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MOTIONPATH_set" "', argument " "2"" of type '" "Dwg_Object_MOTIONPATH *""'"); 
  }
  arg2 = (Dwg_Object_MOTIONPATH *)(argp2);
  if (arg1) (arg1)->MOTIONPATH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MOTIONPATH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MOTIONPATH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MOTIONPATH_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MOTIONPATH *) ((arg1)->MOTIONPATH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MOTIONPATH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *arg2 = (Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->MTEXTATTRIBUTEOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *) ((arg1)->MTEXTATTRIBUTEOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_NAVISWORKSMODELDEF_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_NAVISWORKSMODELDEF *arg2 = (Dwg_Object_NAVISWORKSMODELDEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_NAVISWORKSMODELDEF_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_NAVISWORKSMODELDEF_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_NAVISWORKSMODELDEF_set" "', argument " "2"" of type '" "Dwg_Object_NAVISWORKSMODELDEF *""'"); 
  }
  arg2 = (Dwg_Object_NAVISWORKSMODELDEF *)(argp2);
  if (arg1) (arg1)->NAVISWORKSMODELDEF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_NAVISWORKSMODELDEF_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_NAVISWORKSMODELDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_NAVISWORKSMODELDEF_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_NAVISWORKSMODELDEF *) ((arg1)->NAVISWORKSMODELDEF);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_NAVISWORKSMODELDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_ORDDIMOBJECTCONTEXTDATA *arg2 = (Dwg_Object_ORDDIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_ORDDIMOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_ORDDIMOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->ORDDIMOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ORDDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_ORDDIMOBJECTCONTEXTDATA *) ((arg1)->ORDDIMOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PERSUBENTMGR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_PERSUBENTMGR *arg2 = (Dwg_Object_PERSUBENTMGR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_PERSUBENTMGR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PERSUBENTMGR_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_PERSUBENTMGR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_PERSUBENTMGR_set" "', argument " "2"" of type '" "Dwg_Object_PERSUBENTMGR *""'"); 
  }
  arg2 = (Dwg_Object_PERSUBENTMGR *)(argp2);
  if (arg1) (arg1)->PERSUBENTMGR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_PERSUBENTMGR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PERSUBENTMGR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_PERSUBENTMGR_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_PERSUBENTMGR *) ((arg1)->PERSUBENTMGR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PERSUBENTMGR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTPATH_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_POINTPATH *arg2 = (Dwg_Object_POINTPATH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_POINTPATH_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTPATH_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_POINTPATH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_POINTPATH_set" "', argument " "2"" of type '" "Dwg_Object_POINTPATH *""'"); 
  }
  arg2 = (Dwg_Object_POINTPATH *)(argp2);
  if (arg1) (arg1)->POINTPATH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_POINTPATH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTPATH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_POINTPATH_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_POINTPATH *) ((arg1)->POINTPATH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTPATH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RADIMLGOBJECTCONTEXTDATA *arg2 = (Dwg_Object_RADIMLGOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_RADIMLGOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_RADIMLGOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->RADIMLGOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RADIMLGOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RADIMLGOBJECTCONTEXTDATA *) ((arg1)->RADIMLGOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_RADIMOBJECTCONTEXTDATA *arg2 = (Dwg_Object_RADIMOBJECTCONTEXTDATA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set" "', argument " "2"" of type '" "Dwg_Object_RADIMOBJECTCONTEXTDATA *""'"); 
  }
  arg2 = (Dwg_Object_RADIMOBJECTCONTEXTDATA *)(argp2);
  if (arg1) (arg1)->RADIMOBJECTCONTEXTDATA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RADIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_RADIMOBJECTCONTEXTDATA *) ((arg1)->RADIMOBJECTCONTEXTDATA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RADIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SUNSTUDY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_SUNSTUDY *arg2 = (Dwg_Object_SUNSTUDY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_SUNSTUDY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SUNSTUDY_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_SUNSTUDY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_SUNSTUDY_set" "', argument " "2"" of type '" "Dwg_Object_SUNSTUDY *""'"); 
  }
  arg2 = (Dwg_Object_SUNSTUDY *)(argp2);
  if (arg1) (arg1)->SUNSTUDY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_SUNSTUDY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SUNSTUDY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_SUNSTUDY_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_SUNSTUDY *) ((arg1)->SUNSTUDY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SUNSTUDY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLECONTENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_TABLECONTENT *arg2 = (Dwg_Object_TABLECONTENT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_TABLECONTENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLECONTENT_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TABLECONTENT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_TABLECONTENT_set" "', argument " "2"" of type '" "Dwg_Object_TABLECONTENT *""'"); 
  }
  arg2 = (Dwg_Object_TABLECONTENT *)(argp2);
  if (arg1) (arg1)->TABLECONTENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TABLECONTENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLECONTENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TABLECONTENT_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_TABLECONTENT *) ((arg1)->TABLECONTENT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLECONTENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TVDEVICEPROPERTIES_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  Dwg_Object_TVDEVICEPROPERTIES *arg2 = (Dwg_Object_TVDEVICEPROPERTIES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_object_tio_TVDEVICEPROPERTIES_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TVDEVICEPROPERTIES_set" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_object_tio_TVDEVICEPROPERTIES_set" "', argument " "2"" of type '" "Dwg_Object_TVDEVICEPROPERTIES *""'"); 
  }
  arg2 = (Dwg_Object_TVDEVICEPROPERTIES *)(argp2);
  if (arg1) (arg1)->TVDEVICEPROPERTIES = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_object_tio_TVDEVICEPROPERTIES_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TVDEVICEPROPERTIES *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_object_tio_TVDEVICEPROPERTIES_get" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  result = (Dwg_Object_TVDEVICEPROPERTIES *) ((arg1)->TVDEVICEPROPERTIES);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TVDEVICEPROPERTIES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_object_object_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_object_object_tio", 0, 0, 0)) SWIG_fail;
  result = (_dwg_object_object_tio *)calloc(1, sizeof(_dwg_object_object_tio));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object_tio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_object_object_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_object_tio *arg1 = (_dwg_object_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object_tio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_object_object_tio" "', argument " "1"" of type '" "_dwg_object_object_tio *""'"); 
  }
  arg1 = (_dwg_object_object_tio *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_object_object_tio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_object_tio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_object_object_tio_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Class_number_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_number_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_number_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_number_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->number = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_number_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_number_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BS) ((arg1)->number);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_proxyflag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_proxyflag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_proxyflag_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_proxyflag_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->proxyflag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_proxyflag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_proxyflag_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BS) ((arg1)->proxyflag);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_appname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_appname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_appname_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Class_appname_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->appname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->appname = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->appname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_appname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_appname_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (char *) ((arg1)->appname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_cppname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_cppname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_cppname_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Class_cppname_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->cppname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->cppname = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->cppname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_cppname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_cppname_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (char *) ((arg1)->cppname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dxfname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_dxfname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dxfname_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Class_dxfname_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->dxfname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->dxfname = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->dxfname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dxfname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dxfname_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (char *) ((arg1)->dxfname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dxfname_u_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_TU arg2 = (BITCODE_TU) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_dxfname_u_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dxfname_u_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Class_dxfname_u_set" "', argument " "2"" of type '" "BITCODE_TU""'"); 
  }
  arg2 = (BITCODE_TU)(argp2);
  if (arg1) (arg1)->dxfname_u = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dxfname_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TU result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dxfname_u_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_TU) ((arg1)->dxfname_u);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_is_zombie_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_is_zombie_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_is_zombie_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_is_zombie_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->is_zombie = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_is_zombie_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_is_zombie_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_B) ((arg1)->is_zombie);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_item_class_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_item_class_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_item_class_id_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_item_class_id_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->item_class_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_item_class_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_item_class_id_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BS) ((arg1)->item_class_id);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_num_instances_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_num_instances_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_num_instances_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_num_instances_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_instances = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_num_instances_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_num_instances_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_instances);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_dwg_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BL) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_maint_version_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_maint_version_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_maint_version_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BL) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_unknown_1_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Class_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Class_unknown_2_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Class_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Class_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  result = (BITCODE_BL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Class(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Class", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_class *)calloc(1, sizeof(struct _dwg_class));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_class, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Class(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_class *arg1 = (struct _dwg_class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Class" "', argument " "1"" of type '" "struct _dwg_class *""'"); 
  }
  arg1 = (struct _dwg_class *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Class_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_class, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Class_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Object_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_size_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_size_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_address_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_address_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_address_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result =  ((arg1)->address);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_type_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_type_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_type_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_BS) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_index_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_index_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_index_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_fixedtype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  enum DWG_OBJECT_TYPE arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_fixedtype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_fixedtype_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_fixedtype_set" "', argument " "2"" of type '" "enum DWG_OBJECT_TYPE""'");
  } 
  arg2 = (enum DWG_OBJECT_TYPE)(val2);
  if (arg1) (arg1)->fixedtype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_fixedtype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  enum DWG_OBJECT_TYPE result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_fixedtype_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (enum DWG_OBJECT_TYPE) ((arg1)->fixedtype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_name_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_name_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->name = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_name_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (char *) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_dxfname_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_dxfname_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_dxfname_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_dxfname_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  free((char*)arg1->dxfname);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->dxfname = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->dxfname = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_dxfname_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_dxfname_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (char *) ((arg1)->dxfname);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_supertype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  Dwg_Object_Supertype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_supertype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_supertype_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_supertype_set" "', argument " "2"" of type '" "Dwg_Object_Supertype""'");
  } 
  arg2 = (Dwg_Object_Supertype)(val2);
  if (arg1) (arg1)->supertype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_supertype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Supertype result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_supertype_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (Dwg_Object_Supertype) ((arg1)->supertype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_tio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_object_tio *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_tio_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (_dwg_object_tio *)& ((arg1)->tio);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_tio, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  Dwg_Handle *arg2 = (Dwg_Handle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_handle_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_handle_set" "', argument " "2"" of type '" "Dwg_Handle *""'"); 
  }
  arg2 = (Dwg_Handle *)(argp2);
  if (arg1) (arg1)->handle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Handle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_handle_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (Dwg_Handle *)& ((arg1)->handle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_handle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  struct _dwg_struct *arg2 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_parent_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_parent_set" "', argument " "2"" of type '" "struct _dwg_struct *""'"); 
  }
  arg2 = (struct _dwg_struct *)(argp2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _dwg_struct *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_parent_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (struct _dwg_struct *) ((arg1)->parent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_klass_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  Dwg_Class *arg2 = (Dwg_Class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_klass_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_klass_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_class, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_klass_set" "', argument " "2"" of type '" "Dwg_Class *""'"); 
  }
  arg2 = (Dwg_Class *)(argp2);
  if (arg1) (arg1)->klass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_klass_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Class *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_klass_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (Dwg_Class *) ((arg1)->klass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_class, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_bitsize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_bitsize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_bitsize_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_bitsize_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->bitsize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_bitsize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_bitsize_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->bitsize);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_bitsize_pos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_bitsize_pos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_bitsize_pos_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_bitsize_pos_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->bitsize_pos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_bitsize_pos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_bitsize_pos_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result =  ((arg1)->bitsize_pos);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_hdlpos_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_hdlpos_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_hdlpos_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_hdlpos_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->hdlpos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_hdlpos_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_hdlpos_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result =  ((arg1)->hdlpos);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_was_bitsize_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_was_bitsize_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_was_bitsize_set_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_was_bitsize_set_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->was_bitsize_set = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_was_bitsize_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_was_bitsize_set_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_B) ((arg1)->was_bitsize_set);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_has_strings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_B arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_has_strings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_has_strings_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_has_strings_set" "', argument " "2"" of type '" "BITCODE_B""'");
  } 
  arg2 = (BITCODE_B)(val2);
  if (arg1) (arg1)->has_strings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_has_strings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_B result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_has_strings_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_B) ((arg1)->has_strings);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_stringstream_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_stringstream_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_stringstream_size_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_stringstream_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->stringstream_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_stringstream_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_stringstream_size_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->stringstream_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_handlestream_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_UMC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_handlestream_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_handlestream_size_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_handlestream_size_set" "', argument " "2"" of type '" "BITCODE_UMC""'");
  } 
  arg2 = (BITCODE_UMC)(val2);
  if (arg1) (arg1)->handlestream_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_handlestream_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_UMC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_handlestream_size_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_UMC) ((arg1)->handlestream_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_common_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_common_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_common_size_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_common_size_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->common_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_common_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_common_size_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result =  ((arg1)->common_size);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_num_unknown_bits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_num_unknown_bits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_num_unknown_bits_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_num_unknown_bits_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_unknown_bits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_num_unknown_bits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_num_unknown_bits_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_unknown_bits);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_unknown_bits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_unknown_bits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_unknown_bits_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_unknown_bits_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->unknown_bits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_unknown_bits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_unknown_bits_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_TF) ((arg1)->unknown_bits);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_num_unknown_rest_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_num_unknown_rest_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_num_unknown_rest_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Object_num_unknown_rest_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_unknown_rest = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_num_unknown_rest_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_num_unknown_rest_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_unknown_rest);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_unknown_rest_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Object_unknown_rest_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_unknown_rest_set" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Object_unknown_rest_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->unknown_rest = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Object_unknown_rest_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Object_unknown_rest_get" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  result = (BITCODE_TF) ((arg1)->unknown_rest);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Object", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_object *)calloc(1, sizeof(struct _dwg_object));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_object *arg1 = (struct _dwg_object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Object" "', argument " "1"" of type '" "struct _dwg_object *""'"); 
  }
  arg1 = (struct _dwg_object *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Object_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_object_tio_entity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *arg1 = (_dwg_object_tio *) 0 ;
  Dwg_Object_Entity *arg2 = (Dwg_Object_Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_tio_entity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_tio_entity_set" "', argument " "1"" of type '" "_dwg_object_tio *""'"); 
  }
  arg1 = (_dwg_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_tio_entity_set" "', argument " "2"" of type '" "Dwg_Object_Entity *""'"); 
  }
  arg2 = (Dwg_Object_Entity *)(argp2);
  if (arg1) (arg1)->entity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_tio_entity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *arg1 = (_dwg_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Entity *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_tio_entity_get" "', argument " "1"" of type '" "_dwg_object_tio *""'"); 
  }
  arg1 = (_dwg_object_tio *)(argp1);
  result = (Dwg_Object_Entity *) ((arg1)->entity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_tio_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *arg1 = (_dwg_object_tio *) 0 ;
  Dwg_Object_Object *arg2 = (Dwg_Object_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_object_tio_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_tio_object_set" "', argument " "1"" of type '" "_dwg_object_tio *""'"); 
  }
  arg1 = (_dwg_object_tio *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_object_tio_object_set" "', argument " "2"" of type '" "Dwg_Object_Object *""'"); 
  }
  arg2 = (Dwg_Object_Object *)(argp2);
  if (arg1) (arg1)->object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_object_tio_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *arg1 = (_dwg_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_tio, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_object_tio_object_get" "', argument " "1"" of type '" "_dwg_object_tio *""'"); 
  }
  arg1 = (_dwg_object_tio *)(argp1);
  result = (Dwg_Object_Object *) ((arg1)->object);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_object_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_object_tio", 0, 0, 0)) SWIG_fail;
  result = (_dwg_object_tio *)calloc(1, sizeof(_dwg_object_tio));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_tio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_object_tio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_object_tio *arg1 = (_dwg_object_tio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_tio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_object_tio" "', argument " "1"" of type '" "_dwg_object_tio *""'"); 
  }
  arg1 = (_dwg_object_tio *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_object_tio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_object_tio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_object_tio_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Chain_chain_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  unsigned char *arg2 = (unsigned char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Chain_chain_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_chain_set" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Chain_chain_set" "', argument " "2"" of type '" "unsigned char *""'"); 
  }
  arg2 = (unsigned char *)(argp2);
  if (arg1) (arg1)->chain = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_chain_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_chain_get" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  result = (unsigned char *) ((arg1)->chain);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Chain_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_size_set" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Chain_size_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_size_get" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  result =  ((arg1)->size);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_byte_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Chain_byte_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_byte_set" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Chain_byte_set" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->byte = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_byte_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_byte_get" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  result =  ((arg1)->byte);
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_bit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Chain_bit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_bit_set" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Chain_bit_set" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = (unsigned char)(val2);
  if (arg1) (arg1)->bit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Chain_bit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Chain_bit_get" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  result = (unsigned char) ((arg1)->bit);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Chain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Chain", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_chain *)calloc(1, sizeof(struct _dwg_chain));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_chain, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Chain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_chain *arg1 = (struct _dwg_chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_chain, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Chain" "', argument " "1"" of type '" "struct _dwg_chain *""'"); 
  }
  arg1 = (struct _dwg_chain *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Chain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_chain, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Chain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Section_number_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_number_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_number_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_number_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->number = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_number_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_number_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RLd) ((arg1)->number);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_size_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_size_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_address_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_address_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_address_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RLL) ((arg1)->address);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_objid_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_objid_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_objid_r11_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_objid_r11_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->objid_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_objid_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_objid_r11_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->objid_r11);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_parent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_parent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_parent_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_parent_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->parent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_parent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_parent_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->parent);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_left_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_left_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->left = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_left_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->left);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_right_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_right_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->right = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_right_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->right);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_x00_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_x00_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_x00_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_x00_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->x00 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_x00_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_x00_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->x00);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  Dwg_Section_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_type_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_type_set" "', argument " "2"" of type '" "Dwg_Section_Type""'");
  } 
  arg2 = (Dwg_Section_Type)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_type_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (Dwg_Section_Type) ((arg1)->type);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  char *arg2 = (char *) (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[64] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_name_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 64);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Section_name_set" "', argument " "2"" of type '" "char [64]""'");
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->name,arg2,64*sizeof(char));
  else memset(arg1->name,0,64*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_name_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (char *)(char *) ((arg1)->name);
  {
    size_t size = SWIG_strnlen(result, 64);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_section_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_section_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_section_type_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_section_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->section_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_section_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_section_type_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->section_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_decomp_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_decomp_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_decomp_data_size_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_decomp_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->decomp_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_decomp_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_decomp_data_size_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->decomp_data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_comp_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_comp_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_comp_data_size_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_comp_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->comp_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_comp_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_comp_data_size_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->comp_data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_compression_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_compression_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_compression_type_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_compression_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->compression_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_compression_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_compression_type_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->compression_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_checksum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_checksum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_checksum_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_checksum_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->checksum = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_checksum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_checksum_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RL) ((arg1)->checksum);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_flags_r11_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_flags_r11_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_flags_r11_set" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_flags_r11_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->flags_r11 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_flags_r11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_flags_r11_get" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  result = (BITCODE_RS) ((arg1)->flags_r11);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Section(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Section", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_section *)calloc(1, sizeof(struct _dwg_section));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_section, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Section(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_section *arg1 = (struct _dwg_section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_section, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Section" "', argument " "1"" of type '" "struct _dwg_section *""'"); 
  }
  arg1 = (struct _dwg_section *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Section_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_section, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Section_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_num_desc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_InfoHdr_num_desc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_num_desc_set" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_InfoHdr_num_desc_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_desc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_num_desc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_num_desc_get" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_desc);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_compressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_InfoHdr_compressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_compressed_set" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_InfoHdr_compressed_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->compressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_compressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_compressed_get" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->compressed);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_max_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_InfoHdr_max_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_max_size_set" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_InfoHdr_max_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->max_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_max_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_max_size_get" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->max_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_encrypted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_InfoHdr_encrypted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_encrypted_set" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_InfoHdr_encrypted_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->encrypted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_encrypted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_encrypted_get" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->encrypted);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_num_desc2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_InfoHdr_num_desc2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_num_desc2_set" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_InfoHdr_num_desc2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_desc2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_InfoHdr_num_desc2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_InfoHdr_num_desc2_get" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_desc2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Section_InfoHdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Section_InfoHdr", 0, 0, 0)) SWIG_fail;
  result = (Dwg_Section_InfoHdr *)calloc(1, sizeof(Dwg_Section_InfoHdr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Dwg_Section_InfoHdr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Section_InfoHdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_InfoHdr *arg1 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_InfoHdr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Section_InfoHdr" "', argument " "1"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg1 = (Dwg_Section_InfoHdr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Section_InfoHdr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Dwg_Section_InfoHdr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Section_InfoHdr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Section_Info_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_size_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_size_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_size_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (int64_t) ((arg1)->size);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_num_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_num_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_num_sections_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_num_sections_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_num_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_num_sections_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_sections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_max_decomp_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_max_decomp_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_max_decomp_size_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_max_decomp_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->max_decomp_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_max_decomp_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_max_decomp_size_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->max_decomp_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_unknown_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_unknown_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_unknown_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_compressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_compressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_compressed_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_compressed_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->compressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_compressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_compressed_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->compressed);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_type_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_type_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_encrypted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_encrypted_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_encrypted_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_encrypted_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->encrypted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_encrypted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_encrypted_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (BITCODE_RL) ((arg1)->encrypted);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  char *arg2 = (char *) (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[64] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_name_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 64);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Section_Info_name_set" "', argument " "2"" of type '" "char [64]""'");
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->name,arg2,64*sizeof(char));
  else memset(arg1->name,0,64*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_name_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (char *)(char *) ((arg1)->name);
  {
    size_t size = SWIG_strnlen(result, 64);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_fixedtype_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  Dwg_Section_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_fixedtype_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_fixedtype_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Section_Info_fixedtype_set" "', argument " "2"" of type '" "Dwg_Section_Type""'");
  } 
  arg2 = (Dwg_Section_Type)(val2);
  if (arg1) (arg1)->fixedtype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_fixedtype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_fixedtype_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (Dwg_Section_Type) ((arg1)->fixedtype);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  Dwg_Section **arg2 = (Dwg_Section **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Section_Info_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_sections_set" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_section, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Section_Info_sections_set" "', argument " "2"" of type '" "Dwg_Section **""'"); 
  }
  arg2 = (Dwg_Section **)(argp2);
  if (arg1) (arg1)->sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Section_Info_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Section_Info_sections_get" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  result = (Dwg_Section **) ((arg1)->sections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_section, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Section_Info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Section_Info", 0, 0, 0)) SWIG_fail;
  result = (Dwg_Section_Info *)calloc(1, sizeof(Dwg_Section_Info));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Dwg_Section_Info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Section_Info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Section_Info *arg1 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Dwg_Section_Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Section_Info" "', argument " "1"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg1 = (Dwg_Section_Info *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Section_Info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Dwg_Section_Info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Section_Info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_Property_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *arg1 = (struct _dwg_SummaryInfo_Property *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_Property_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SummaryInfo_Property, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_Property_tag_set" "', argument " "1"" of type '" "struct _dwg_SummaryInfo_Property *""'"); 
  }
  arg1 = (struct _dwg_SummaryInfo_Property *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_Property_tag_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->tag);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->tag = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->tag = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_Property_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *arg1 = (struct _dwg_SummaryInfo_Property *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SummaryInfo_Property, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_Property_tag_get" "', argument " "1"" of type '" "struct _dwg_SummaryInfo_Property *""'"); 
  }
  arg1 = (struct _dwg_SummaryInfo_Property *)(argp1);
  result = (BITCODE_TV) ((arg1)->tag);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_Property_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *arg1 = (struct _dwg_SummaryInfo_Property *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_Property_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SummaryInfo_Property, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_Property_value_set" "', argument " "1"" of type '" "struct _dwg_SummaryInfo_Property *""'"); 
  }
  arg1 = (struct _dwg_SummaryInfo_Property *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_Property_value_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->value);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->value = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->value = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_Property_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *arg1 = (struct _dwg_SummaryInfo_Property *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SummaryInfo_Property, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_Property_value_get" "', argument " "1"" of type '" "struct _dwg_SummaryInfo_Property *""'"); 
  }
  arg1 = (struct _dwg_SummaryInfo_Property *)(argp1);
  result = (BITCODE_TV) ((arg1)->value);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SummaryInfo_Property(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SummaryInfo_Property", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_SummaryInfo_Property *)calloc(1, sizeof(struct _dwg_SummaryInfo_Property));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SummaryInfo_Property, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SummaryInfo_Property(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_SummaryInfo_Property *arg1 = (struct _dwg_SummaryInfo_Property *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_SummaryInfo_Property, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SummaryInfo_Property" "', argument " "1"" of type '" "struct _dwg_SummaryInfo_Property *""'"); 
  }
  arg1 = (struct _dwg_SummaryInfo_Property *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SummaryInfo_Property_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_SummaryInfo_Property, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SummaryInfo_Property_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filename_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_Files_filename_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->filename);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->filename = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->filename = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filename_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_TV) ((arg1)->filename);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filepath_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_filepath_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filepath_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_Files_filepath_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->filepath);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->filepath = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->filepath = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filepath_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filepath_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_TV) ((arg1)->filepath);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_fingerprint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_fingerprint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_fingerprint_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_Files_fingerprint_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->fingerprint);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->fingerprint = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->fingerprint = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_fingerprint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_fingerprint_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_TV) ((arg1)->fingerprint);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_version_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_Files_version_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->version);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->version = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->version = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_version_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_TV) ((arg1)->version);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_feature_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_feature_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_feature_index_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_Files_feature_index_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->feature_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_feature_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_feature_index_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_RL) ((arg1)->feature_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_timestamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_timestamp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_timestamp_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_Files_timestamp_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->timestamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_timestamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_timestamp_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_RL) ((arg1)->timestamp);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filesize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_filesize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filesize_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_Files_filesize_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->filesize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_filesize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_filesize_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_RL) ((arg1)->filesize);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_affects_graphics_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_affects_graphics_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_affects_graphics_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_Files_affects_graphics_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->affects_graphics = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_affects_graphics_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_affects_graphics_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_RS) ((arg1)->affects_graphics);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_refcount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_Files_refcount_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_refcount_set" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_Files_refcount_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->refcount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_Files_refcount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_Files_refcount_get" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  result = (BITCODE_RL) ((arg1)->refcount);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_FileDepList_Files(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_FileDepList_Files", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_FileDepList_Files *)calloc(1, sizeof(struct _dwg_FileDepList_Files));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FileDepList_Files, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_FileDepList_Files(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_FileDepList_Files *arg1 = (struct _dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_FileDepList_Files, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_FileDepList_Files" "', argument " "1"" of type '" "struct _dwg_FileDepList_Files *""'"); 
  }
  arg1 = (struct _dwg_FileDepList_Files *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_FileDepList_Files_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_FileDepList_Files, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_FileDepList_Files_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_SegmentIndex_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *arg1 = (struct _dwg_AcDs_SegmentIndex *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SegmentIndex_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SegmentIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SegmentIndex_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SegmentIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SegmentIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SegmentIndex_offset_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SegmentIndex_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *arg1 = (struct _dwg_AcDs_SegmentIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SegmentIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SegmentIndex_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SegmentIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SegmentIndex *)(argp1);
  result = (BITCODE_RLL) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SegmentIndex_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *arg1 = (struct _dwg_AcDs_SegmentIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SegmentIndex_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SegmentIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SegmentIndex_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SegmentIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SegmentIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SegmentIndex_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SegmentIndex_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *arg1 = (struct _dwg_AcDs_SegmentIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SegmentIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SegmentIndex_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SegmentIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SegmentIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_SegmentIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_SegmentIndex", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_SegmentIndex *)calloc(1, sizeof(struct _dwg_AcDs_SegmentIndex));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SegmentIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_SegmentIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SegmentIndex *arg1 = (struct _dwg_AcDs_SegmentIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SegmentIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_SegmentIndex" "', argument " "1"" of type '" "struct _dwg_AcDs_SegmentIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SegmentIndex *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_SegmentIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_SegmentIndex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_SegmentIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_Entry_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataIndex_Entry_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  result = (BITCODE_RL) ((arg1)->segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_Entry_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataIndex_Entry_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  result = (BITCODE_RL) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_schidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_Entry_schidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_schidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataIndex_Entry_schidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->schidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_Entry_schidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_Entry_schidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  result = (BITCODE_RL) ((arg1)->schidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataIndex_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataIndex_Entry", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataIndex_Entry *)calloc(1, sizeof(struct _dwg_AcDs_DataIndex_Entry));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataIndex_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex_Entry *arg1 = (struct _dwg_AcDs_DataIndex_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataIndex_Entry" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex_Entry *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataIndex_Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataIndex_Entry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_num_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_num_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_num_entries_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataIndex_num_entries_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_num_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_num_entries_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_entries);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_di_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_di_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_di_unknown_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataIndex_di_unknown_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->di_unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_di_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_di_unknown_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->di_unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  Dwg_AcDs_DataIndex_Entry *arg2 = (Dwg_AcDs_DataIndex_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataIndex_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_entries_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_DataIndex_entries_set" "', argument " "2"" of type '" "Dwg_AcDs_DataIndex_Entry *""'"); 
  }
  arg2 = (Dwg_AcDs_DataIndex_Entry *)(argp2);
  if (arg1) (arg1)->entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataIndex_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_DataIndex_Entry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataIndex_entries_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  result = (Dwg_AcDs_DataIndex_Entry *) ((arg1)->entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataIndex_Entry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataIndex", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataIndex *)calloc(1, sizeof(struct _dwg_AcDs_DataIndex));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataIndex *arg1 = (struct _dwg_AcDs_DataIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataIndex" "', argument " "1"" of type '" "struct _dwg_AcDs_DataIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataIndex *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataIndex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_entry_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_RecordHdr_entry_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_entry_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Data_RecordHdr_entry_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->entry_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_entry_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_entry_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->entry_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_RecordHdr_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_unknown_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Data_RecordHdr_unknown_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_unknown_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_RecordHdr_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_handle_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Data_RecordHdr_handle_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_handle_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  result = (BITCODE_RLL) ((arg1)->handle);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_RecordHdr_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Data_RecordHdr_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_RecordHdr_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_RecordHdr_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  result = (BITCODE_RL) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Data_RecordHdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Data_RecordHdr", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Data_RecordHdr *)calloc(1, sizeof(struct _dwg_AcDs_Data_RecordHdr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Data_RecordHdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_RecordHdr *arg1 = (struct _dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Data_RecordHdr" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_RecordHdr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Data_RecordHdr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Data_RecordHdr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_Record_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *arg1 = (struct _dwg_AcDs_Data_Record *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_Record_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_Record, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_Record_data_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_Record *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_Record *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Data_Record_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_Record_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *arg1 = (struct _dwg_AcDs_Data_Record *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_Record, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_Record_data_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_Record *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_Record *)(argp1);
  result = (BITCODE_RL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_Record_blob_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *arg1 = (struct _dwg_AcDs_Data_Record *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_Record_blob_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_Record, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_Record_blob_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_Record *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_Record *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Data_Record_blob_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->blob = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_Record_blob_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *arg1 = (struct _dwg_AcDs_Data_Record *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_Record, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_Record_blob_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_Record *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_Record *)(argp1);
  result = (BITCODE_RC *) ((arg1)->blob);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Data_Record(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Data_Record", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Data_Record *)calloc(1, sizeof(struct _dwg_AcDs_Data_Record));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data_Record, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Data_Record(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data_Record *arg1 = (struct _dwg_AcDs_Data_Record *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data_Record, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Data_Record" "', argument " "1"" of type '" "struct _dwg_AcDs_Data_Record *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data_Record *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Data_Record_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Data_Record, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Data_Record_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_record_hdrs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *arg1 = (struct _dwg_AcDs_Data *) 0 ;
  Dwg_AcDs_Data_RecordHdr *arg2 = (Dwg_AcDs_Data_RecordHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_record_hdrs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_record_hdrs_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Data_record_hdrs_set" "', argument " "2"" of type '" "Dwg_AcDs_Data_RecordHdr *""'"); 
  }
  arg2 = (Dwg_AcDs_Data_RecordHdr *)(argp2);
  if (arg1) (arg1)->record_hdrs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_record_hdrs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *arg1 = (struct _dwg_AcDs_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Data_RecordHdr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_record_hdrs_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data *)(argp1);
  result = (Dwg_AcDs_Data_RecordHdr *) ((arg1)->record_hdrs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data_RecordHdr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_records_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *arg1 = (struct _dwg_AcDs_Data *) 0 ;
  Dwg_AcDs_Data_Record *arg2 = (Dwg_AcDs_Data_Record *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Data_records_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_records_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Data_Record, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Data_records_set" "', argument " "2"" of type '" "Dwg_AcDs_Data_Record *""'"); 
  }
  arg2 = (Dwg_AcDs_Data_Record *)(argp2);
  if (arg1) (arg1)->records = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Data_records_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *arg1 = (struct _dwg_AcDs_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Data_Record *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Data_records_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data *)(argp1);
  result = (Dwg_AcDs_Data_Record *) ((arg1)->records);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data_Record, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Data", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Data *)calloc(1, sizeof(struct _dwg_AcDs_Data));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Data *arg1 = (struct _dwg_AcDs_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Data" "', argument " "1"" of type '" "struct _dwg_AcDs_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Data *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_Page_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *arg1 = (struct _dwg_AcDs_DataBlobRef_Page *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_Page_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_Page_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef_Page *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_Page_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_Page_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *arg1 = (struct _dwg_AcDs_DataBlobRef_Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_Page_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef_Page *)(argp1);
  result = (BITCODE_RL) ((arg1)->segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_Page_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *arg1 = (struct _dwg_AcDs_DataBlobRef_Page *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_Page_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_Page_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef_Page *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_Page_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_Page_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *arg1 = (struct _dwg_AcDs_DataBlobRef_Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_Page_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef_Page *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataBlobRef_Page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataBlobRef_Page", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataBlobRef_Page *)calloc(1, sizeof(struct _dwg_AcDs_DataBlobRef_Page));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataBlobRef_Page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef_Page *arg1 = (struct _dwg_AcDs_DataBlobRef_Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataBlobRef_Page" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef_Page *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataBlobRef_Page_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataBlobRef_Page_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_total_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_total_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_total_data_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_total_data_size_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->total_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_total_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_total_data_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RLL) ((arg1)->total_data_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_num_pages_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_num_pages_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_num_pages_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_num_pages_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_pages = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_num_pages_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_num_pages_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_pages);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_record_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_record_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_record_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_record_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->record_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_record_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_record_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RL) ((arg1)->record_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_page_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_page_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_page_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_page_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->page_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_page_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_page_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RL) ((arg1)->page_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlobRef_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_pages_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  Dwg_AcDs_DataBlobRef_Page *arg2 = (Dwg_AcDs_DataBlobRef_Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlobRef_pages_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_pages_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_DataBlobRef_pages_set" "', argument " "2"" of type '" "Dwg_AcDs_DataBlobRef_Page *""'"); 
  }
  arg2 = (Dwg_AcDs_DataBlobRef_Page *)(argp2);
  if (arg1) (arg1)->pages = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlobRef_pages_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_DataBlobRef_Page *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlobRef_pages_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  result = (Dwg_AcDs_DataBlobRef_Page *) ((arg1)->pages);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlobRef_Page, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataBlobRef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataBlobRef", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataBlobRef *)calloc(1, sizeof(struct _dwg_AcDs_DataBlobRef));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlobRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataBlobRef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlobRef *arg1 = (struct _dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlobRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataBlobRef" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlobRef *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlobRef *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataBlobRef_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataBlobRef, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataBlobRef_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_data_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_data_size_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_data_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RLL) ((arg1)->data_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_page_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_page_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_page_count_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_page_count_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->page_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_page_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_page_count_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RL) ((arg1)->page_count);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_record_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_record_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_record_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_record_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->record_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_record_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_record_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RL) ((arg1)->record_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_page_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_page_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_page_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_page_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->page_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_page_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_page_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RL) ((arg1)->page_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  Dwg_AcDs_DataBlobRef *arg2 = (Dwg_AcDs_DataBlobRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_ref_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_DataBlobRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_DataBlob_ref_set" "', argument " "2"" of type '" "Dwg_AcDs_DataBlobRef *""'"); 
  }
  arg2 = (Dwg_AcDs_DataBlobRef *)(argp2);
  if (arg1) (arg1)->ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_DataBlobRef *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob_ref_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  result = (Dwg_AcDs_DataBlobRef *) ((arg1)->ref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlobRef, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataBlob(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataBlob", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataBlob *)calloc(1, sizeof(struct _dwg_AcDs_DataBlob));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlob, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataBlob(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob *arg1 = (struct _dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataBlob" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataBlob_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataBlob, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataBlob_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_total_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_total_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_total_data_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob01_total_data_size_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->total_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_total_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_total_data_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (BITCODE_RLL) ((arg1)->total_data_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_start_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_page_start_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_start_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob01_page_start_offset_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->page_start_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_start_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_start_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (BITCODE_RLL) ((arg1)->page_start_offset);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_page_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_index_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob01_page_index_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = (int32_t)(val2);
  if (arg1) (arg1)->page_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_index_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (int32_t) ((arg1)->page_index);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_count_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_page_count_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_count_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob01_page_count_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = (int32_t)(val2);
  if (arg1) (arg1)->page_count = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_count_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_count_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (int32_t) ((arg1)->page_count);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_page_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_data_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_DataBlob01_page_data_size_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->page_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_data_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (BITCODE_RLL) ((arg1)->page_data_size);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_DataBlob01_page_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_data_set" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_DataBlob01_page_data_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->page_data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_DataBlob01_page_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_DataBlob01_page_data_get" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  result = (BITCODE_RC *) ((arg1)->page_data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_DataBlob01(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_DataBlob01", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_DataBlob01 *)calloc(1, sizeof(struct _dwg_AcDs_DataBlob01));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlob01, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_DataBlob01(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_DataBlob01 *arg1 = (struct _dwg_AcDs_DataBlob01 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_DataBlob01, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_DataBlob01" "', argument " "1"" of type '" "struct _dwg_AcDs_DataBlob01 *""'"); 
  }
  arg1 = (struct _dwg_AcDs_DataBlob01 *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_DataBlob01_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_DataBlob01, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_DataBlob01_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_Prop_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_index_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_Prop_index_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_index_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_Prop_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_Prop_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_Prop_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_Prop_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_Prop_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_Prop_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_SchemaIndex_Prop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_SchemaIndex_Prop", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_SchemaIndex_Prop *)calloc(1, sizeof(struct _dwg_AcDs_SchemaIndex_Prop));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_SchemaIndex_Prop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex_Prop *arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_SchemaIndex_Prop" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex_Prop *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_SchemaIndex_Prop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_SchemaIndex_Prop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_num_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_num_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_num_props_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_num_props_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_num_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_num_props_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_props);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_si_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->si_unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->si_unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  Dwg_AcDs_SchemaIndex_Prop *arg2 = (Dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_props_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_SchemaIndex_props_set" "', argument " "2"" of type '" "Dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg2 = (Dwg_AcDs_SchemaIndex_Prop *)(argp2);
  if (arg1) (arg1)->props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SchemaIndex_Prop *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_props_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (Dwg_AcDs_SchemaIndex_Prop *) ((arg1)->props);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_tag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_si_tag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_tag_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_si_tag_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->si_tag = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_tag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_tag_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (BITCODE_RLL) ((arg1)->si_tag);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_num_prop_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_num_prop_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_num_prop_entries_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_num_prop_entries_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_prop_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_num_prop_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_num_prop_entries_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_prop_entries);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_si_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->si_unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_si_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_si_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (BITCODE_RL) ((arg1)->si_unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_prop_entries_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  Dwg_AcDs_SchemaIndex_Prop *arg2 = (Dwg_AcDs_SchemaIndex_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaIndex_prop_entries_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_prop_entries_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_SchemaIndex_prop_entries_set" "', argument " "2"" of type '" "Dwg_AcDs_SchemaIndex_Prop *""'"); 
  }
  arg2 = (Dwg_AcDs_SchemaIndex_Prop *)(argp2);
  if (arg1) (arg1)->prop_entries = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaIndex_prop_entries_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SchemaIndex_Prop *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaIndex_prop_entries_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  result = (Dwg_AcDs_SchemaIndex_Prop *) ((arg1)->prop_entries);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaIndex_Prop, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_SchemaIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_SchemaIndex", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_SchemaIndex *)calloc(1, sizeof(struct _dwg_AcDs_SchemaIndex));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_SchemaIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaIndex *arg1 = (struct _dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_SchemaIndex" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaIndex *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaIndex *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_SchemaIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_SchemaIndex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_SchemaIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_flags_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_flags_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_flags_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_namidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_namidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_namidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_namidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->namidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_namidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_namidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->namidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_type_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_type_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_type_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_type_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_type_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_type_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->type_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_type_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_type_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->type_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_num_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_num_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_num_values_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_Prop_num_values_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_num_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_num_values_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_values);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_values_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_Prop_values_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_values_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Schema_Prop_values_set" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  if (arg1) (arg1)->values = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_Prop_values_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_Prop_values_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  result = (BITCODE_RC *) ((arg1)->values);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Schema_Prop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Schema_Prop", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Schema_Prop *)calloc(1, sizeof(struct _dwg_AcDs_Schema_Prop));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Schema_Prop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Schema_Prop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema_Prop *arg1 = (struct _dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema_Prop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Schema_Prop" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema_Prop *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema_Prop *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Schema_Prop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Schema_Prop, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Schema_Prop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_num_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_num_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_num_index_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_num_index_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_num_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_num_index_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_index);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  BITCODE_RLL *arg2 = (BITCODE_RLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_index_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Schema_index_set" "', argument " "2"" of type '" "BITCODE_RLL *""'"); 
  }
  arg2 = (BITCODE_RLL *)(argp2);
  if (arg1) (arg1)->index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_index_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  result = (BITCODE_RLL *) ((arg1)->index);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_num_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_num_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_num_props_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Schema_num_props_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_num_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_num_props_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  Dwg_AcDs_Schema_Prop *arg2 = (Dwg_AcDs_Schema_Prop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Schema_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_props_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Schema_Prop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Schema_props_set" "', argument " "2"" of type '" "Dwg_AcDs_Schema_Prop *""'"); 
  }
  arg2 = (Dwg_AcDs_Schema_Prop *)(argp2);
  if (arg1) (arg1)->props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Schema_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Schema_Prop *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Schema_props_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  result = (Dwg_AcDs_Schema_Prop *) ((arg1)->props);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Schema_Prop, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Schema(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Schema", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Schema *)calloc(1, sizeof(struct _dwg_AcDs_Schema));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Schema, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Schema(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Schema *arg1 = (struct _dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Schema, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Schema" "', argument " "1"" of type '" "struct _dwg_AcDs_Schema *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Schema *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Schema_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Schema, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Schema_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_UProp_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *arg1 = (struct _dwg_AcDs_SchemaData_UProp *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_UProp_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_UProp_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData_UProp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaData_UProp_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_UProp_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *arg1 = (struct _dwg_AcDs_SchemaData_UProp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_UProp_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData_UProp *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_UProp_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *arg1 = (struct _dwg_AcDs_SchemaData_UProp *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_UProp_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_UProp_flags_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData_UProp *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaData_UProp_flags_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->flags = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_UProp_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *arg1 = (struct _dwg_AcDs_SchemaData_UProp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_UProp_flags_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData_UProp *)(argp1);
  result = (BITCODE_RL) ((arg1)->flags);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_SchemaData_UProp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_SchemaData_UProp", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_SchemaData_UProp *)calloc(1, sizeof(struct _dwg_AcDs_SchemaData_UProp));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_SchemaData_UProp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData_UProp *arg1 = (struct _dwg_AcDs_SchemaData_UProp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_SchemaData_UProp" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData_UProp *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_SchemaData_UProp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_SchemaData_UProp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_uprops_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_num_uprops_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_uprops_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaData_num_uprops_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_uprops = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_uprops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_uprops_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_uprops);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_uprops_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  Dwg_AcDs_SchemaData_UProp *arg2 = (Dwg_AcDs_SchemaData_UProp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_uprops_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_uprops_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_SchemaData_uprops_set" "', argument " "2"" of type '" "Dwg_AcDs_SchemaData_UProp *""'"); 
  }
  arg2 = (Dwg_AcDs_SchemaData_UProp *)(argp2);
  if (arg1) (arg1)->uprops = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_uprops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SchemaData_UProp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_uprops_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (Dwg_AcDs_SchemaData_UProp *) ((arg1)->uprops);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaData_UProp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_schemas_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_num_schemas_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_schemas_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaData_num_schemas_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_schemas = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_schemas_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_schemas_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_schemas);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_schemas_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  Dwg_AcDs_Schema *arg2 = (Dwg_AcDs_Schema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_schemas_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_schemas_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Schema, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_SchemaData_schemas_set" "', argument " "2"" of type '" "Dwg_AcDs_Schema *""'"); 
  }
  arg2 = (Dwg_AcDs_Schema *)(argp2);
  if (arg1) (arg1)->schemas = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_schemas_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Schema *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_schemas_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (Dwg_AcDs_Schema *) ((arg1)->schemas);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Schema, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_propnames_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_num_propnames_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_propnames_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_SchemaData_num_propnames_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_propnames = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_num_propnames_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_num_propnames_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_propnames);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_propnames_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_SchemaData_propnames_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_propnames_set" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_SchemaData_propnames_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->propnames = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_SchemaData_propnames_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_SchemaData_propnames_get" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  result = (BITCODE_TV *) ((arg1)->propnames);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_SchemaData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_SchemaData", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_SchemaData *)calloc(1, sizeof(struct _dwg_AcDs_SchemaData));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_SchemaData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_SchemaData *arg1 = (struct _dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_SchemaData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_SchemaData" "', argument " "1"" of type '" "struct _dwg_AcDs_SchemaData *""'"); 
  }
  arg1 = (struct _dwg_AcDs_SchemaData *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_SchemaData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_SchemaData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_SchemaData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_handle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_IdIdx_handle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_handle_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_IdIdx_handle_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->handle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_handle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_handle_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  result = (BITCODE_RLL) ((arg1)->handle);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_num_ididx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_IdIdx_num_ididx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_num_ididx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_IdIdx_num_ididx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_ididx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_num_ididx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_num_ididx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_ididx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_ididx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  BITCODE_RLL *arg2 = (BITCODE_RLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_IdIdx_ididx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_ididx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Search_IdIdx_ididx_set" "', argument " "2"" of type '" "BITCODE_RLL *""'"); 
  }
  arg2 = (BITCODE_RLL *)(argp2);
  if (arg1) (arg1)->ididx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdx_ididx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdx_ididx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  result = (BITCODE_RLL *) ((arg1)->ididx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Search_IdIdx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Search_IdIdx", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Search_IdIdx *)calloc(1, sizeof(struct _dwg_AcDs_Search_IdIdx));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_IdIdx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Search_IdIdx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdx *arg1 = (struct _dwg_AcDs_Search_IdIdx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Search_IdIdx" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdx *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Search_IdIdx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Search_IdIdx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Search_IdIdx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdxs_num_ididx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *arg1 = (struct _dwg_AcDs_Search_IdIdxs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_IdIdxs_num_ididx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdxs_num_ididx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdxs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_IdIdxs_num_ididx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_ididx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdxs_num_ididx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *arg1 = (struct _dwg_AcDs_Search_IdIdxs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdxs_num_ididx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdxs *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_ididx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdxs_ididx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *arg1 = (struct _dwg_AcDs_Search_IdIdxs *) 0 ;
  Dwg_AcDs_Search_IdIdx *arg2 = (Dwg_AcDs_Search_IdIdx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_IdIdxs_ididx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdxs_ididx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdxs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Search_IdIdx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Search_IdIdxs_ididx_set" "', argument " "2"" of type '" "Dwg_AcDs_Search_IdIdx *""'"); 
  }
  arg2 = (Dwg_AcDs_Search_IdIdx *)(argp2);
  if (arg1) (arg1)->ididx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_IdIdxs_ididx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *arg1 = (struct _dwg_AcDs_Search_IdIdxs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Search_IdIdx *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_IdIdxs_ididx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdxs *)(argp1);
  result = (Dwg_AcDs_Search_IdIdx *) ((arg1)->ididx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_IdIdx, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Search_IdIdxs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Search_IdIdxs", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Search_IdIdxs *)calloc(1, sizeof(struct _dwg_AcDs_Search_IdIdxs));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Search_IdIdxs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_IdIdxs *arg1 = (struct _dwg_AcDs_Search_IdIdxs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Search_IdIdxs" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_IdIdxs *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Search_IdIdxs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Search_IdIdxs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_schema_namidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_schema_namidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_schema_namidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_Data_schema_namidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->schema_namidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_schema_namidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_schema_namidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (BITCODE_RL) ((arg1)->schema_namidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_num_sortedidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_num_sortedidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_num_sortedidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_Data_num_sortedidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_sortedidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_num_sortedidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_num_sortedidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_sortedidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_sortedidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  BITCODE_RLLd *arg2 = (BITCODE_RLLd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_sortedidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_sortedidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_long_long, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Search_Data_sortedidx_set" "', argument " "2"" of type '" "BITCODE_RLLd *""'"); 
  }
  arg2 = (BITCODE_RLLd *)(argp2);
  if (arg1) (arg1)->sortedidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_sortedidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLLd *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_sortedidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (BITCODE_RLLd *) ((arg1)->sortedidx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_num_ididxs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_num_ididxs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_num_ididxs_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_Data_num_ididxs_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_ididxs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_num_ididxs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_num_ididxs_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_ididxs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_unknown_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_Data_unknown_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_unknown_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_ididxs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  Dwg_AcDs_Search_IdIdxs *arg2 = (Dwg_AcDs_Search_IdIdxs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_Data_ididxs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_ididxs_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Search_Data_ididxs_set" "', argument " "2"" of type '" "Dwg_AcDs_Search_IdIdxs *""'"); 
  }
  arg2 = (Dwg_AcDs_Search_IdIdxs *)(argp2);
  if (arg1) (arg1)->ididxs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_Data_ididxs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Search_IdIdxs *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_Data_ididxs_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  result = (Dwg_AcDs_Search_IdIdxs *) ((arg1)->ididxs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_IdIdxs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Search_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Search_Data", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Search_Data *)calloc(1, sizeof(struct _dwg_AcDs_Search_Data));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_Data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Search_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search_Data *arg1 = (struct _dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Search_Data" "', argument " "1"" of type '" "struct _dwg_AcDs_Search_Data *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search_Data *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Search_Data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Search_Data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Search_Data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_num_search_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *arg1 = (struct _dwg_AcDs_Search *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_num_search_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_num_search_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Search_num_search_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_search = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_num_search_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *arg1 = (struct _dwg_AcDs_Search *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_num_search_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_search);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_search_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *arg1 = (struct _dwg_AcDs_Search *) 0 ;
  Dwg_AcDs_Search_Data *arg2 = (Dwg_AcDs_Search_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Search_search_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_search_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Search *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Search_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Search_search_set" "', argument " "2"" of type '" "Dwg_AcDs_Search_Data *""'"); 
  }
  arg2 = (Dwg_AcDs_Search_Data *)(argp2);
  if (arg1) (arg1)->search = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Search_search_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *arg1 = (struct _dwg_AcDs_Search *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Search_Data *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Search_search_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Search *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search *)(argp1);
  result = (Dwg_AcDs_Search_Data *) ((arg1)->search);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search_Data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Search", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Search *)calloc(1, sizeof(struct _dwg_AcDs_Search));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Search *arg1 = (struct _dwg_AcDs_Search *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Search, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Search" "', argument " "1"" of type '" "struct _dwg_AcDs_Search *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Search *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Search_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Search, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Search_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_signature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_signature_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_signature_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_signature_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->signature = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_signature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_signature_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RS) ((arg1)->signature);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_name_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Segment_name_set" "', argument " "2"" of type '" "BITCODE_RC [7]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(BITCODE_RC *)&arg1->name[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""name""' of type '""BITCODE_RC [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_name_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_type_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_type_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_type_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RCd) ((arg1)->type);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_segment_idx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_segment_idx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_segment_idx_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_segment_idx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segment_idx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_segment_idx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_segment_idx_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->segment_idx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_is_blob01_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_is_blob01_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_is_blob01_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_is_blob01_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->is_blob01 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_is_blob01_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_is_blob01_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->is_blob01);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_segsize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_segsize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_segsize_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_segsize_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segsize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_segsize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_segsize_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->segsize);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_ds_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_ds_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_ds_version_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_ds_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->ds_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_ds_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_ds_version_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->ds_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_unknown_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_unknown_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_unknown_3_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_unknown_3_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_unknown_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_unknown_3_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_data_algn_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_data_algn_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_data_algn_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_data_algn_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->data_algn_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_data_algn_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_data_algn_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->data_algn_offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_objdata_algn_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_objdata_algn_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_objdata_algn_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_Segment_objdata_algn_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->objdata_algn_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_objdata_algn_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_objdata_algn_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RL) ((arg1)->objdata_algn_offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_padding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_Segment_padding_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_padding_set" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_Segment_padding_set" "', argument " "2"" of type '" "BITCODE_RC [9]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)9; ++ii) *(BITCODE_RC *)&arg1->padding[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""padding""' of type '""BITCODE_RC [9]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_Segment_padding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_Segment_padding_get" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->padding);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs_Segment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs_Segment", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs_Segment *)calloc(1, sizeof(struct _dwg_AcDs_Segment));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Segment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs_Segment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs_Segment *arg1 = (struct _dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs_Segment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs_Segment" "', argument " "1"" of type '" "struct _dwg_AcDs_Segment *""'"); 
  }
  arg1 = (struct _dwg_AcDs_Segment *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_Segment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs_Segment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_Segment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_signature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_file_signature_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_signature_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_file_signature_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->file_signature = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_signature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_signature_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->file_signature);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_header_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_file_header_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_header_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_file_header_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->file_header_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_header_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_header_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->file_header_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_version_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_version_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_ds_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_ds_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_ds_version_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_ds_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->ds_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_ds_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_ds_version_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->ds_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_segidx_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_offset_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_segidx_offset_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segidx_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_offset_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->segidx_offset);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_unknown_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_segidx_unknown_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_unknown_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_segidx_unknown_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->segidx_unknown = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_unknown_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_unknown_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->segidx_unknown);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_num_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_num_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_num_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_num_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_num_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_num_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schidx_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_schidx_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schidx_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_schidx_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->schidx_segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schidx_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schidx_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->schidx_segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_datidx_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_datidx_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_datidx_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_datidx_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->datidx_segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_datidx_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_datidx_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->datidx_segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_search_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_search_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_search_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_search_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->search_segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_search_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_search_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->search_segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_prvsav_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_prvsav_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_prvsav_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_prvsav_segidx_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->prvsav_segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_prvsav_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_prvsav_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->prvsav_segidx);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_file_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_size_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_file_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->file_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_file_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_file_size_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_RL) ((arg1)->file_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_total_segments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_total_segments_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_total_segments_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AcDs_total_segments_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->total_segments = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_total_segments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_total_segments_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (BITCODE_BL) ((arg1)->total_segments);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_SegmentIndex *arg2 = (Dwg_AcDs_SegmentIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_segidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SegmentIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_segidx_set" "', argument " "2"" of type '" "Dwg_AcDs_SegmentIndex *""'"); 
  }
  arg2 = (Dwg_AcDs_SegmentIndex *)(argp2);
  if (arg1) (arg1)->segidx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SegmentIndex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_SegmentIndex *) ((arg1)->segidx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SegmentIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_datidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_DataIndex *arg2 = (Dwg_AcDs_DataIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_datidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_datidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_datidx_set" "', argument " "2"" of type '" "Dwg_AcDs_DataIndex *""'"); 
  }
  arg2 = (Dwg_AcDs_DataIndex *)(argp2);
  if (arg1) (arg1)->datidx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_datidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_DataIndex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_datidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_DataIndex *)& ((arg1)->datidx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_Data *arg2 = (Dwg_AcDs_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_data_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_data_set" "', argument " "2"" of type '" "Dwg_AcDs_Data *""'"); 
  }
  arg2 = (Dwg_AcDs_Data *)(argp2);
  if (arg1) (arg1)->data = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Data *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_data_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_Data *) ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_blob01_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_DataBlob *arg2 = (Dwg_AcDs_DataBlob *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_blob01_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_blob01_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_blob01_set" "', argument " "2"" of type '" "Dwg_AcDs_DataBlob *""'"); 
  }
  arg2 = (Dwg_AcDs_DataBlob *)(argp2);
  if (arg1) (arg1)->blob01 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_blob01_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_DataBlob *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_blob01_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_DataBlob *)& ((arg1)->blob01);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_DataBlob, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schidx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_SchemaIndex *arg2 = (Dwg_AcDs_SchemaIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_schidx_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schidx_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_schidx_set" "', argument " "2"" of type '" "Dwg_AcDs_SchemaIndex *""'"); 
  }
  arg2 = (Dwg_AcDs_SchemaIndex *)(argp2);
  if (arg1) (arg1)->schidx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schidx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SchemaIndex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schidx_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_SchemaIndex *)& ((arg1)->schidx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaIndex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schdat_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_SchemaData *arg2 = (Dwg_AcDs_SchemaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_schdat_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schdat_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_schdat_set" "', argument " "2"" of type '" "Dwg_AcDs_SchemaData *""'"); 
  }
  arg2 = (Dwg_AcDs_SchemaData *)(argp2);
  if (arg1) (arg1)->schdat = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_schdat_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_SchemaData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_schdat_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_SchemaData *)& ((arg1)->schdat);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_SchemaData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_search_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_Search *arg2 = (Dwg_AcDs_Search *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_search_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_search_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_search_set" "', argument " "2"" of type '" "Dwg_AcDs_Search *""'"); 
  }
  arg2 = (Dwg_AcDs_Search *)(argp2);
  if (arg1) (arg1)->search = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_search_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Search *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_search_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_Search *)& ((arg1)->search);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Search, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segments_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  Dwg_AcDs_Segment *arg2 = (Dwg_AcDs_Segment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AcDs_segments_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segments_set" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs_Segment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AcDs_segments_set" "', argument " "2"" of type '" "Dwg_AcDs_Segment *""'"); 
  }
  arg2 = (Dwg_AcDs_Segment *)(argp2);
  if (arg1) (arg1)->segments = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AcDs_segments_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs_Segment *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AcDs_segments_get" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  result = (Dwg_AcDs_Segment *) ((arg1)->segments);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs_Segment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AcDs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AcDs", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_AcDs *)calloc(1, sizeof(struct _dwg_AcDs));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AcDs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_AcDs *arg1 = (struct _dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_AcDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AcDs" "', argument " "1"" of type '" "struct _dwg_AcDs *""'"); 
  }
  arg1 = (struct _dwg_AcDs *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AcDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_AcDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AcDs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Header_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  Dwg_Version_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_version_set" "', argument " "2"" of type '" "Dwg_Version_Type""'");
  } 
  arg2 = (Dwg_Version_Type)(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Version_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (Dwg_Version_Type) ((arg1)->version);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_from_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  Dwg_Version_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_from_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_from_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_from_version_set" "', argument " "2"" of type '" "Dwg_Version_Type""'");
  } 
  arg2 = (Dwg_Version_Type)(val2);
  if (arg1) (arg1)->from_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_from_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Version_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_from_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (Dwg_Version_Type) ((arg1)->from_version);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_is_maint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_is_maint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_is_maint_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_is_maint_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_maint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_is_maint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_is_maint_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_maint);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_zero_one_or_three_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_zero_one_or_three_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_zero_one_or_three_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_zero_one_or_three_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->zero_one_or_three = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_zero_one_or_three_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_zero_one_or_three_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->zero_one_or_three);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_numentity_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_numentity_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_numentity_sections_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_numentity_sections_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numentity_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_numentity_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_numentity_sections_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RS) ((arg1)->numentity_sections);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_numheader_vars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_numheader_vars_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_numheader_vars_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_numheader_vars_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numheader_vars = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_numheader_vars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_numheader_vars_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RS) ((arg1)->numheader_vars);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_thumbnail_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_thumbnail_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_thumbnail_address_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_thumbnail_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->thumbnail_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_thumbnail_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_thumbnail_address_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->thumbnail_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_dwg_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_maint_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_maint_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_maint_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_entities_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_entities_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_entities_start_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_entities_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->entities_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_entities_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_entities_start_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->entities_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_entities_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_entities_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_entities_end_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_entities_end_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->entities_end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_entities_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_entities_end_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->entities_end);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_blocks_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_blocks_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_blocks_start_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_blocks_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->blocks_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_blocks_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_blocks_start_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->blocks_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_blocks_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_blocks_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_blocks_size_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_blocks_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->blocks_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_blocks_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_blocks_size_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->blocks_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_extras_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_extras_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_extras_start_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_extras_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->extras_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_extras_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_extras_start_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->extras_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_extras_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_extras_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_extras_size_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_extras_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->extras_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_extras_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_extras_size_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->extras_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_codepage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_codepage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_codepage_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_codepage_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->codepage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_codepage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_codepage_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RS) ((arg1)->codepage);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_unknown_0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_unknown_0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_unknown_0_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_unknown_0_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->unknown_0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_unknown_0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_unknown_0_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->unknown_0);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_app_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_app_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_app_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_app_dwg_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->app_dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_app_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_app_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->app_dwg_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_app_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_app_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_app_maint_version_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_app_maint_version_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->app_maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_app_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_app_maint_version_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RC) ((arg1)->app_maint_version);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_security_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_security_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_security_type_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_security_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->security_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_security_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_security_type_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->security_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_rl_1c_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_rl_1c_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_rl_1c_address_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_rl_1c_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->rl_1c_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_rl_1c_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_rl_1c_address_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->rl_1c_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_summaryinfo_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_summaryinfo_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_summaryinfo_address_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_summaryinfo_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->summaryinfo_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_summaryinfo_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_summaryinfo_address_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->summaryinfo_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_vbaproj_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_vbaproj_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_vbaproj_address_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_vbaproj_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->vbaproj_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_vbaproj_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_vbaproj_address_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->vbaproj_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_r2004_header_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_r2004_header_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_r2004_header_address_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_r2004_header_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->r2004_header_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_r2004_header_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_r2004_header_address_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->r2004_header_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_sections_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_sections_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_sections_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->sections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_num_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_num_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_num_sections_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Header_num_sections_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_num_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_num_sections_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_sections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  Dwg_Section *arg2 = (Dwg_Section *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_section_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_section, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_section_set" "', argument " "2"" of type '" "Dwg_Section *""'"); 
  }
  arg2 = (Dwg_Section *)(argp2);
  if (arg1) (arg1)->section = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (Dwg_Section *) ((arg1)->section);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_section, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_infohdr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  Dwg_Section_InfoHdr *arg2 = (Dwg_Section_InfoHdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_section_infohdr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_infohdr_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_section_infohdr_set" "', argument " "2"" of type '" "Dwg_Section_InfoHdr *""'"); 
  }
  arg2 = (Dwg_Section_InfoHdr *)(argp2);
  if (arg1) (arg1)->section_infohdr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_infohdr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_InfoHdr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_infohdr_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (Dwg_Section_InfoHdr *)& ((arg1)->section_infohdr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Dwg_Section_InfoHdr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_info_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  Dwg_Section_Info *arg2 = (Dwg_Section_Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Header_section_info_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_info_set" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Dwg_Section_Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Header_section_info_set" "', argument " "2"" of type '" "Dwg_Section_Info *""'"); 
  }
  arg2 = (Dwg_Section_Info *)(argp2);
  if (arg1) (arg1)->section_info = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Header_section_info_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_Info *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Header_section_info_get" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  result = (Dwg_Section_Info *) ((arg1)->section_info);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Dwg_Section_Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Header", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_header *)calloc(1, sizeof(struct _dwg_header));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_header *arg1 = (struct _dwg_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_header, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Header" "', argument " "1"" of type '" "struct _dwg_header *""'"); 
  }
  arg1 = (struct _dwg_header *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Header_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_header, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Header_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_header_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header_size_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_header_size_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->header_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header_size_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->header_size);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_file_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_file_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_file_size_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_file_size_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->file_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_file_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_file_size_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->file_size);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_compressed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_crc_compressed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_compressed_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_crc_compressed_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_crc_compressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_compressed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_compressed_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_crc_compressed);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_correction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_correction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_correction_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_correction_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_correction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_correction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_correction_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_correction);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_seed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_crc_seed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_seed_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_crc_seed_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_crc_seed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_seed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_seed_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_crc_seed);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map2_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map2_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map2_offset_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map2_offset_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map2_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map2_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map2_offset_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map2_offset);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map2_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map2_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map2_id_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map2_id_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map2_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map2_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map2_id_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map2_id);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_offset_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_offset_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_offset_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_offset);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_id_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_id_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_id_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_id);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header2_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_header2_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header2_offset_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_header2_offset_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->header2_offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header2_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header2_offset_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->header2_offset);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_size_comp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_size_comp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_size_comp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_size_comp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_size_comp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_size_comp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_size_comp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_size_comp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_size_uncomp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_size_uncomp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_size_uncomp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_size_uncomp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_size_uncomp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_size_uncomp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_size_uncomp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_size_uncomp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_amount_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_amount_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_amount_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_amount_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_amount = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_amount_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_amount_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_amount);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_maxid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_maxid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_maxid_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_maxid_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_maxid = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_maxid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_maxid_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_maxid);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_unknown1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown1_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_unknown1_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->unknown1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown1_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->unknown1);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_unknown2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown2_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_unknown2_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->unknown2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown2_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->unknown2);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_uncomp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_pages_map_crc_uncomp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_uncomp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_pages_map_crc_uncomp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->pages_map_crc_uncomp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_pages_map_crc_uncomp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_pages_map_crc_uncomp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->pages_map_crc_uncomp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_unknown3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown3_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_unknown3_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->unknown3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown3_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->unknown3);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_unknown4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown4_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_unknown4_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->unknown4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown4_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->unknown4);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_unknown5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown5_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_unknown5_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->unknown5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_unknown5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_unknown5_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->unknown5);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_num_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_num_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_num_sections_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_num_sections_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->num_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_num_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_num_sections_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->num_sections);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_uncomp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_crc_uncomp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_uncomp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_crc_uncomp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_crc_uncomp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_uncomp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_uncomp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_crc_uncomp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_size_comp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_size_comp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_size_comp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_size_comp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_size_comp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_size_comp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_size_comp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_size_comp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map2_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map2_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map2_id_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map2_id_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map2_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map2_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map2_id_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map2_id);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_id_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_id_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_id_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_id);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_size_uncomp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_size_uncomp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_size_uncomp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_size_uncomp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_size_uncomp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_size_uncomp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_size_uncomp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_size_uncomp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_comp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_crc_comp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_comp_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_crc_comp_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_crc_comp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_comp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_comp_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_crc_comp);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_correction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_correction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_correction_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_correction_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_correction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_correction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_correction_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_correction);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_seed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_sections_map_crc_seed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_seed_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_sections_map_crc_seed_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->sections_map_crc_seed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_sections_map_crc_seed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_sections_map_crc_seed_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->sections_map_crc_seed);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_stream_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_stream_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_stream_version_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_stream_version_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->stream_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_stream_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_stream_version_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->stream_version);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_crc_seed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_crc_seed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_crc_seed_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_crc_seed_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->crc_seed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_crc_seed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_crc_seed_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->crc_seed);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_crc_seed_encoded_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_crc_seed_encoded_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_crc_seed_encoded_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_crc_seed_encoded_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->crc_seed_encoded = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_crc_seed_encoded_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_crc_seed_encoded_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->crc_seed_encoded);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_random_seed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_random_seed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_random_seed_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_random_seed_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->random_seed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_random_seed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_random_seed_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->random_seed);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header_crc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2007_Header_header_crc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header_crc_set" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2007_Header_header_crc_set" "', argument " "2"" of type '" "int64_t""'");
  } 
  arg2 = (int64_t)(val2);
  if (arg1) (arg1)->header_crc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2007_Header_header_crc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int64_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2007_Header_header_crc_get" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  result = (int64_t) ((arg1)->header_crc);
  resultobj = SWIG_From_long_SS_long((long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_R2007_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_R2007_Header", 0, 0, 0)) SWIG_fail;
  result = (struct r2007_file_header *)calloc(1, sizeof(struct r2007_file_header));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_r2007_file_header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_R2007_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct r2007_file_header *arg1 = (struct r2007_file_header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_r2007_file_header, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_R2007_Header" "', argument " "1"" of type '" "struct r2007_file_header *""'"); 
  }
  arg1 = (struct r2007_file_header *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_R2007_Header_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_r2007_file_header, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_R2007_Header_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_file_ID_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_file_ID_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_file_ID_string_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_R2004_Header_file_ID_string_set" "', argument " "2"" of type '" "BITCODE_RC [12]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(BITCODE_RC *)&arg1->file_ID_string[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""file_ID_string""' of type '""BITCODE_RC [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_file_ID_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_file_ID_string_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->file_ID_string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_header_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_header_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_header_address_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_header_address_set" "', argument " "2"" of type '" "BITCODE_RLx""'");
  } 
  arg2 = (BITCODE_RLx)(val2);
  if (arg1) (arg1)->header_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_header_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_header_address_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLx) ((arg1)->header_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_header_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_header_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_header_size_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_header_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->header_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_header_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_header_size_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->header_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x04_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_x04_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x04_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_x04_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->x04 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x04_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x04_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->x04);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_root_tree_node_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_root_tree_node_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_root_tree_node_gap_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_root_tree_node_gap_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->root_tree_node_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_root_tree_node_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_root_tree_node_gap_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLd) ((arg1)->root_tree_node_gap);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_lowermost_left_tree_node_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_lowermost_left_tree_node_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_lowermost_left_tree_node_gap_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_lowermost_left_tree_node_gap_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->lowermost_left_tree_node_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_lowermost_left_tree_node_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_lowermost_left_tree_node_gap_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLd) ((arg1)->lowermost_left_tree_node_gap);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_lowermost_right_tree_node_gap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_lowermost_right_tree_node_gap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_lowermost_right_tree_node_gap_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_lowermost_right_tree_node_gap_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->lowermost_right_tree_node_gap = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_lowermost_right_tree_node_gap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_lowermost_right_tree_node_gap_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLd) ((arg1)->lowermost_right_tree_node_gap);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_unknown_long_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_unknown_long_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_unknown_long_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_unknown_long_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_long = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_unknown_long_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_unknown_long_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_long);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_last_section_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_last_section_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_last_section_id_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_last_section_id_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->last_section_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_last_section_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_last_section_id_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->last_section_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_last_section_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_last_section_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_last_section_address_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_last_section_address_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->last_section_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_last_section_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_last_section_address_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLL) ((arg1)->last_section_address);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_secondheader_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_secondheader_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_secondheader_address_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_secondheader_address_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->secondheader_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_secondheader_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_secondheader_address_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLL) ((arg1)->secondheader_address);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_numgaps_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_numgaps_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_numgaps_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_numgaps_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->numgaps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_numgaps_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_numgaps_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->numgaps);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_numsections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_numsections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_numsections_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_numsections_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->numsections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_numsections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_numsections_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->numsections);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x20_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_x20_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x20_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_x20_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->x20 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x20_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x20_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->x20);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x80_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_x80_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x80_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_x80_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->x80 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x80_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x80_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->x80);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x40_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_x40_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x40_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_x40_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->x40 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_x40_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_x40_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->x40);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_map_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_section_map_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_map_id_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_section_map_id_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->section_map_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_map_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_map_id_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->section_map_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_map_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_section_map_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_map_address_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_section_map_address_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->section_map_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_map_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_map_address_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLL) ((arg1)->section_map_address);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_info_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_section_info_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_info_id_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_section_info_id_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->section_info_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_info_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_info_id_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLd) ((arg1)->section_info_id);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_array_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_section_array_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_array_size_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_section_array_size_set" "', argument " "2"" of type '" "BITCODE_RLd""'");
  } 
  arg2 = (BITCODE_RLd)(val2);
  if (arg1) (arg1)->section_array_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_array_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_array_size_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLd) ((arg1)->section_array_size);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_gap_array_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_gap_array_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_gap_array_size_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_gap_array_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->gap_array_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_gap_array_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_gap_array_size_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->gap_array_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_crc32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_crc32_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_crc32_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_crc32_set" "', argument " "2"" of type '" "BITCODE_RLx""'");
  } 
  arg2 = (BITCODE_RLx)(val2);
  if (arg1) (arg1)->crc32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_crc32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_crc32_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLx) ((arg1)->crc32);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_padding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_padding_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_padding_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_R2004_Header_padding_set" "', argument " "2"" of type '" "BITCODE_RC [12]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(BITCODE_RC *)&arg1->padding[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""padding""' of type '""BITCODE_RC [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_padding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_padding_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->padding);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_section_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_type_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_section_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->section_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_section_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_section_type_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->section_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_decomp_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_decomp_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_decomp_data_size_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_decomp_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->decomp_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_decomp_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_decomp_data_size_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->decomp_data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_comp_data_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_comp_data_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_comp_data_size_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_comp_data_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->comp_data_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_comp_data_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_comp_data_size_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->comp_data_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_compression_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_compression_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_compression_type_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_compression_type_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->compression_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_compression_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_compression_type_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RL) ((arg1)->compression_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_checksum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  BITCODE_RLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_R2004_Header_checksum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_checksum_set" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_R2004_Header_checksum_set" "', argument " "2"" of type '" "BITCODE_RLx""'");
  } 
  arg2 = (BITCODE_RLx)(val2);
  if (arg1) (arg1)->checksum = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_R2004_Header_checksum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_R2004_Header_checksum_get" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  result = (BITCODE_RLx) ((arg1)->checksum);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_R2004_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_R2004_Header", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_R2004_Header *)calloc(1, sizeof(struct _dwg_R2004_Header));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_R2004_Header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_R2004_Header(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_R2004_Header *arg1 = (struct _dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_R2004_Header, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_R2004_Header" "', argument " "1"" of type '" "struct _dwg_R2004_Header *""'"); 
  }
  arg1 = (struct _dwg_R2004_Header *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_R2004_Header_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_R2004_Header, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_R2004_Header_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_aux_intro_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_aux_intro_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_aux_intro_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_aux_intro_set" "', argument " "2"" of type '" "BITCODE_RC [3]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(BITCODE_RC *)&arg1->aux_intro[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""aux_intro""' of type '""BITCODE_RC [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_aux_intro_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_aux_intro_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->aux_intro);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_dwg_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_dwg_version_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->dwg_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->dwg_version);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_maint_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_maint_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->maint_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->maint_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_numsaves_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_numsaves_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->numsaves = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->numsaves);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_minus_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_minus_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_minus_1_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_minus_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->minus_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_minus_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_minus_1_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->minus_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_numsaves_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_1_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_numsaves_1_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numsaves_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_1_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->numsaves_1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_numsaves_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_2_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_numsaves_2_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numsaves_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_2_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->numsaves_2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_dwg_version_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_1_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_dwg_version_1_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->dwg_version_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_1_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->dwg_version_1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_maint_version_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_1_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_maint_version_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->maint_version_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_1_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->maint_version_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_dwg_version_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_2_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_dwg_version_2_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->dwg_version_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_dwg_version_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_dwg_version_2_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->dwg_version_2);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_maint_version_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_2_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_maint_version_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->maint_version_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_maint_version_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_maint_version_2_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->maint_version_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_unknown_6rs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS *arg2 = (BITCODE_RS *) (BITCODE_RS *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_unknown_6rs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_unknown_6rs_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_unknown_6rs_set" "', argument " "2"" of type '" "BITCODE_RS [6]""'"); 
  } 
  arg2 = (BITCODE_RS *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(BITCODE_RS *)&arg1->unknown_6rs[ii] = *((BITCODE_RS *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""unknown_6rs""' of type '""BITCODE_RS [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_unknown_6rs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_unknown_6rs_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS *)(BITCODE_RS *) ((arg1)->unknown_6rs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_unknown_5rl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL *arg2 = (BITCODE_RL *) (BITCODE_RL *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_unknown_5rl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_unknown_5rl_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_unknown_5rl_set" "', argument " "2"" of type '" "BITCODE_RL [5]""'"); 
  } 
  arg2 = (BITCODE_RL *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)5; ++ii) *(BITCODE_RL *)&arg1->unknown_5rl[ii] = *((BITCODE_RL *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""unknown_5rl""' of type '""BITCODE_RL [5]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_unknown_5rl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_unknown_5rl_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL *)(BITCODE_RL *) ((arg1)->unknown_5rl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_TDCREATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_TDCREATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_TDCREATE_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_TDCREATE_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDCREATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_TDCREATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_TDCREATE_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDCREATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_TDUPDATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_TDUPDATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_TDUPDATE_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_TDUPDATE_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDUPDATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_TDUPDATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_TDUPDATE_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDUPDATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_HANDSEED_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_HV arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_HANDSEED_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_HANDSEED_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_HANDSEED_set" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  if (arg1) (arg1)->HANDSEED = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_HANDSEED_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_HV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_HANDSEED_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_HV) ((arg1)->HANDSEED);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_plot_stamp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_plot_stamp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_plot_stamp_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_plot_stamp_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->plot_stamp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_plot_stamp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_plot_stamp_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->plot_stamp);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_1_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_1_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->zero_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_1_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->zero_1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_numsaves_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_3_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_numsaves_3_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->numsaves_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_3_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->numsaves_3);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_2_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_2_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_3_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_3_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_3_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_4_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_4_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_4_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_4);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_numsaves_4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_4_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_numsaves_4_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->numsaves_4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_numsaves_4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_numsaves_4_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->numsaves_4);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_5_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_5_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_5_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_5);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_6_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_6_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_6_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_6_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_6 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_6_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_6_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_6);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_7_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_7_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_7_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_7_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_7 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_7_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_7_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_7);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_8_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_8_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_8_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_zero_8_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->zero_8 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_8_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_8_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->zero_8);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_18_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS *arg2 = (BITCODE_RS *) (BITCODE_RS *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_zero_18_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_18_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AuxHeader_zero_18_set" "', argument " "2"" of type '" "BITCODE_RS [3]""'"); 
  } 
  arg2 = (BITCODE_RS *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(BITCODE_RS *)&arg1->zero_18[ii] = *((BITCODE_RS *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""zero_18""' of type '""BITCODE_RS [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_zero_18_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_zero_18_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS *)(BITCODE_RS *) ((arg1)->zero_18);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_num_auxheader_variables_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_num_auxheader_variables_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_num_auxheader_variables_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_num_auxheader_variables_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_auxheader_variables = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_num_auxheader_variables_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_num_auxheader_variables_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_auxheader_variables);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_auxheader_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_auxheader_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_auxheader_size_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_auxheader_size_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->auxheader_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_auxheader_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_auxheader_size_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->auxheader_size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_entities_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_entities_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_entities_start_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_entities_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->entities_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_entities_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_entities_start_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->entities_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_entities_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_entities_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_entities_end_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_entities_end_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->entities_end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_entities_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_entities_end_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->entities_end);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_blocks_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_blocks_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_blocks_start_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_blocks_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->blocks_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_blocks_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_blocks_start_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->blocks_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_extras_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_extras_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_extras_start_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_extras_start_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->extras_start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_extras_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_extras_start_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->extras_start);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_auxheader_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RLx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_auxheader_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_auxheader_address_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_auxheader_address_set" "', argument " "2"" of type '" "BITCODE_RLx""'");
  } 
  arg2 = (BITCODE_RLx)(val2);
  if (arg1) (arg1)->auxheader_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_auxheader_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLx result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_auxheader_address_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RLx) ((arg1)->auxheader_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_num_aux_tables_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_num_aux_tables_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_num_aux_tables_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_num_aux_tables_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_aux_tables = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_num_aux_tables_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_num_aux_tables_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_aux_tables);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_R11_HANDLING_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AuxHeader_R11_HANDLING_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_R11_HANDLING_set" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AuxHeader_R11_HANDLING_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->R11_HANDLING = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AuxHeader_R11_HANDLING_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AuxHeader_R11_HANDLING_get" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  result = (BITCODE_BS) ((arg1)->R11_HANDLING);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AuxHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AuxHeader", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_auxheader *)calloc(1, sizeof(struct _dwg_auxheader));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_auxheader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AuxHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_auxheader *arg1 = (struct _dwg_auxheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_auxheader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AuxHeader" "', argument " "1"" of type '" "struct _dwg_auxheader *""'"); 
  }
  arg1 = (struct _dwg_auxheader *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AuxHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_auxheader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AuxHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TITLE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_TITLE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TITLE_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_TITLE_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->TITLE);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->TITLE = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->TITLE = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TITLE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TITLE_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->TITLE);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_SUBJECT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_SUBJECT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_SUBJECT_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_SUBJECT_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->SUBJECT);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->SUBJECT = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->SUBJECT = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_SUBJECT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_SUBJECT_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->SUBJECT);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_AUTHOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_AUTHOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_AUTHOR_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_AUTHOR_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->AUTHOR);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->AUTHOR = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->AUTHOR = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_AUTHOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_AUTHOR_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->AUTHOR);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_KEYWORDS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_KEYWORDS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_KEYWORDS_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_KEYWORDS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->KEYWORDS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->KEYWORDS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->KEYWORDS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_KEYWORDS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_KEYWORDS_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->KEYWORDS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_COMMENTS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_COMMENTS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_COMMENTS_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_COMMENTS_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->COMMENTS);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->COMMENTS = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->COMMENTS = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_COMMENTS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_COMMENTS_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->COMMENTS);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_LASTSAVEDBY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_LASTSAVEDBY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_LASTSAVEDBY_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_LASTSAVEDBY_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->LASTSAVEDBY);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->LASTSAVEDBY = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->LASTSAVEDBY = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_LASTSAVEDBY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_LASTSAVEDBY_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->LASTSAVEDBY);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_REVISIONNUMBER_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_REVISIONNUMBER_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_REVISIONNUMBER_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_REVISIONNUMBER_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->REVISIONNUMBER);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->REVISIONNUMBER = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->REVISIONNUMBER = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_REVISIONNUMBER_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_REVISIONNUMBER_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->REVISIONNUMBER);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_HYPERLINKBASE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_HYPERLINKBASE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_HYPERLINKBASE_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_HYPERLINKBASE_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->HYPERLINKBASE);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->HYPERLINKBASE = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->HYPERLINKBASE = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_HYPERLINKBASE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_HYPERLINKBASE_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->HYPERLINKBASE);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDINDWG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_TDINDWG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDINDWG_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_TDINDWG_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDINDWG = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDINDWG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDINDWG_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDINDWG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDCREATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_TDCREATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDCREATE_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_TDCREATE_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDCREATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDCREATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDCREATE_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDCREATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDUPDATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_TDUPDATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDUPDATE_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_TDUPDATE_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDUPDATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_TDUPDATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_TDUPDATE_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDUPDATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_num_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_num_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_num_props_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SummaryInfo_num_props_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->num_props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_num_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_num_props_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_RS) ((arg1)->num_props);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_props_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  Dwg_SummaryInfo_Property *arg2 = (Dwg_SummaryInfo_Property *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_props_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_props_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_SummaryInfo_Property, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SummaryInfo_props_set" "', argument " "2"" of type '" "Dwg_SummaryInfo_Property *""'"); 
  }
  arg2 = (Dwg_SummaryInfo_Property *)(argp2);
  if (arg1) (arg1)->props = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_props_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SummaryInfo_Property *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_props_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (Dwg_SummaryInfo_Property *) ((arg1)->props);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_SummaryInfo_Property, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_unknown1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_unknown1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_unknown1_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SummaryInfo_unknown1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_unknown1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_unknown1_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_unknown2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SummaryInfo_unknown2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_unknown2_set" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SummaryInfo_unknown2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SummaryInfo_unknown2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SummaryInfo_unknown2_get" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SummaryInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SummaryInfo", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_summaryinfo *)calloc(1, sizeof(struct _dwg_summaryinfo));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_summaryinfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SummaryInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_summaryinfo *arg1 = (struct _dwg_summaryinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_summaryinfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SummaryInfo" "', argument " "1"" of type '" "struct _dwg_summaryinfo *""'"); 
  }
  arg1 = (struct _dwg_summaryinfo *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SummaryInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_summaryinfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SummaryInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AppInfo_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_class_version_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AppInfo_class_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_class_version_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_RL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_num_strings_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_num_strings_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_num_strings_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AppInfo_num_strings_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_strings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_num_strings_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_num_strings_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_strings);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_appinfo_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_appinfo_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_appinfo_name_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_appinfo_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->appinfo_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->appinfo_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->appinfo_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_appinfo_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_appinfo_name_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->appinfo_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_version_checksum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_version_checksum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_version_checksum_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_version_checksum_set" "', argument " "2"" of type '" "BITCODE_RC [16]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)16; ++ii) *(BITCODE_RC *)&arg1->version_checksum[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""version_checksum""' of type '""BITCODE_RC [16]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_version_checksum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_version_checksum_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->version_checksum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_comment_checksum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_comment_checksum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_comment_checksum_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_comment_checksum_set" "', argument " "2"" of type '" "BITCODE_RC [16]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)16; ++ii) *(BITCODE_RC *)&arg1->comment_checksum[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""comment_checksum""' of type '""BITCODE_RC [16]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_comment_checksum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_comment_checksum_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->comment_checksum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_product_checksum_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_product_checksum_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_product_checksum_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_product_checksum_set" "', argument " "2"" of type '" "BITCODE_RC [16]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)16; ++ii) *(BITCODE_RC *)&arg1->product_checksum[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""product_checksum""' of type '""BITCODE_RC [16]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_product_checksum_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_product_checksum_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->product_checksum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_version_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_version_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->version);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->version = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->version = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_version_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->version);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_comment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_comment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_comment_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_comment_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->comment);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->comment = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->comment = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_comment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_comment_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->comment);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_product_info_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfo_product_info_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_product_info_set" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfo_product_info_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->product_info);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->product_info = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->product_info = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfo_product_info_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfo_product_info_get" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  result = (BITCODE_TV) ((arg1)->product_info);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AppInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AppInfo", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_appinfo *)calloc(1, sizeof(struct _dwg_appinfo));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_appinfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AppInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfo *arg1 = (struct _dwg_appinfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AppInfo" "', argument " "1"" of type '" "struct _dwg_appinfo *""'"); 
  }
  arg1 = (struct _dwg_appinfo *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AppInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_appinfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AppInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_FileDepList_num_features_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_num_features_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_num_features_set" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_num_features_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_features = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_num_features_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_num_features_get" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_features);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_features_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  BITCODE_TV *arg2 = (BITCODE_TV *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_features_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_features_set" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_features_set" "', argument " "2"" of type '" "BITCODE_TV *""'"); 
  }
  arg2 = (BITCODE_TV *)(argp2);
  if (arg1) (arg1)->features = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_features_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_features_get" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  result = (BITCODE_TV *) ((arg1)->features);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_num_files_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_num_files_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_num_files_set" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_FileDepList_num_files_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_files = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_num_files_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_num_files_get" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_files);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_files_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  Dwg_FileDepList_Files *arg2 = (Dwg_FileDepList_Files *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_FileDepList_files_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_files_set" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_FileDepList_Files, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_FileDepList_files_set" "', argument " "2"" of type '" "Dwg_FileDepList_Files *""'"); 
  }
  arg2 = (Dwg_FileDepList_Files *)(argp2);
  if (arg1) (arg1)->files = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_FileDepList_files_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FileDepList_Files *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_FileDepList_files_get" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  result = (Dwg_FileDepList_Files *) ((arg1)->files);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_FileDepList_Files, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_FileDepList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_FileDepList", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_filedeplist *)calloc(1, sizeof(struct _dwg_filedeplist));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_filedeplist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_FileDepList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_filedeplist *arg1 = (struct _dwg_filedeplist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_filedeplist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_FileDepList" "', argument " "1"" of type '" "struct _dwg_filedeplist *""'"); 
  }
  arg1 = (struct _dwg_filedeplist *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_FileDepList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_filedeplist, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_FileDepList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_unknown_1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_1_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_unknown_1_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_1_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_unknown_2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_2_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_unknown_2_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_2_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_unknown_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_3_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_unknown_3_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->unknown_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_unknown_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_unknown_3_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->unknown_3);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_crypto_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_crypto_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_crypto_id_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_crypto_id_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->crypto_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_crypto_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_crypto_id_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->crypto_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_crypto_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_crypto_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_crypto_name_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Security_crypto_name_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->crypto_name);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->crypto_name = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->crypto_name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_crypto_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_crypto_name_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_TV) ((arg1)->crypto_name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_algo_id_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_algo_id_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_algo_id_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_algo_id_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->algo_id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_algo_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_algo_id_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->algo_id);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_key_len_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_key_len_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_key_len_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_key_len_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->key_len = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_key_len_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_key_len_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->key_len);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_encr_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_encr_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_encr_size_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Security_encr_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->encr_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_encr_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_encr_size_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_RL) ((arg1)->encr_size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_encr_buffer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Security_encr_buffer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_encr_buffer_set" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Security_encr_buffer_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->encr_buffer = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Security_encr_buffer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Security_encr_buffer_get" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  result = (BITCODE_TF) ((arg1)->encr_buffer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Security(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Security", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_security *)calloc(1, sizeof(struct _dwg_security));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_security, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Security(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_security *arg1 = (struct _dwg_security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_security, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Security" "', argument " "1"" of type '" "struct _dwg_security *""'"); 
  }
  arg1 = (struct _dwg_security *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Security_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_security, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Security_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_VBAProject_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *arg1 = (struct _dwg_vbaproject *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VBAProject_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VBAProject_size_set" "', argument " "1"" of type '" "struct _dwg_vbaproject *""'"); 
  }
  arg1 = (struct _dwg_vbaproject *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_VBAProject_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VBAProject_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *arg1 = (struct _dwg_vbaproject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VBAProject_size_get" "', argument " "1"" of type '" "struct _dwg_vbaproject *""'"); 
  }
  arg1 = (struct _dwg_vbaproject *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VBAProject_unknown_bits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *arg1 = (struct _dwg_vbaproject *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_VBAProject_unknown_bits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VBAProject_unknown_bits_set" "', argument " "1"" of type '" "struct _dwg_vbaproject *""'"); 
  }
  arg1 = (struct _dwg_vbaproject *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_VBAProject_unknown_bits_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->unknown_bits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_VBAProject_unknown_bits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *arg1 = (struct _dwg_vbaproject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_VBAProject_unknown_bits_get" "', argument " "1"" of type '" "struct _dwg_vbaproject *""'"); 
  }
  arg1 = (struct _dwg_vbaproject *)(argp1);
  result = (BITCODE_TF) ((arg1)->unknown_bits);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_VBAProject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_VBAProject", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_vbaproject *)calloc(1, sizeof(struct _dwg_vbaproject));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_vbaproject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_VBAProject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_vbaproject *arg1 = (struct _dwg_vbaproject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_vbaproject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_VBAProject" "', argument " "1"" of type '" "struct _dwg_vbaproject *""'"); 
  }
  arg1 = (struct _dwg_vbaproject *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_VBAProject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_vbaproject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_VBAProject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_AppInfoHistory_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *arg1 = (struct _dwg_appinfohistory *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfoHistory_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfoHistory_size_set" "', argument " "1"" of type '" "struct _dwg_appinfohistory *""'"); 
  }
  arg1 = (struct _dwg_appinfohistory *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_AppInfoHistory_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfoHistory_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *arg1 = (struct _dwg_appinfohistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfoHistory_size_get" "', argument " "1"" of type '" "struct _dwg_appinfohistory *""'"); 
  }
  arg1 = (struct _dwg_appinfohistory *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfoHistory_unknown_bits_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *arg1 = (struct _dwg_appinfohistory *) 0 ;
  BITCODE_TF arg2 = (BITCODE_TF) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_AppInfoHistory_unknown_bits_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfoHistory_unknown_bits_set" "', argument " "1"" of type '" "struct _dwg_appinfohistory *""'"); 
  }
  arg1 = (struct _dwg_appinfohistory *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_AppInfoHistory_unknown_bits_set" "', argument " "2"" of type '" "BITCODE_TF""'"); 
  }
  arg2 = (BITCODE_TF)(argp2);
  if (arg1) (arg1)->unknown_bits = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_AppInfoHistory_unknown_bits_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *arg1 = (struct _dwg_appinfohistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TF result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_AppInfoHistory_unknown_bits_get" "', argument " "1"" of type '" "struct _dwg_appinfohistory *""'"); 
  }
  arg1 = (struct _dwg_appinfohistory *)(argp1);
  result = (BITCODE_TF) ((arg1)->unknown_bits);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_AppInfoHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_AppInfoHistory", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_appinfohistory *)calloc(1, sizeof(struct _dwg_appinfohistory));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_appinfohistory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_AppInfoHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_appinfohistory *arg1 = (struct _dwg_appinfohistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_appinfohistory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_AppInfoHistory" "', argument " "1"" of type '" "struct _dwg_appinfohistory *""'"); 
  }
  arg1 = (struct _dwg_appinfohistory *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_AppInfoHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_appinfohistory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_AppInfoHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_RevHistory_class_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RevHistory_class_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_class_version_set" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RevHistory_class_version_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->class_version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_class_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_class_version_get" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  result = (BITCODE_RL) ((arg1)->class_version);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_class_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RevHistory_class_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_class_minor_set" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RevHistory_class_minor_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->class_minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_class_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_class_minor_get" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  result = (BITCODE_RL) ((arg1)->class_minor);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_num_histories_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RevHistory_num_histories_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_num_histories_set" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RevHistory_num_histories_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->num_histories = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_num_histories_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_num_histories_get" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  result = (BITCODE_RL) ((arg1)->num_histories);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_histories_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  BITCODE_RL *arg2 = (BITCODE_RL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RevHistory_histories_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_histories_set" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_RevHistory_histories_set" "', argument " "2"" of type '" "BITCODE_RL *""'"); 
  }
  arg2 = (BITCODE_RL *)(argp2);
  if (arg1) (arg1)->histories = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RevHistory_histories_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RevHistory_histories_get" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  result = (BITCODE_RL *) ((arg1)->histories);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_RevHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_RevHistory", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_revhistory *)calloc(1, sizeof(struct _dwg_revhistory));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_revhistory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_RevHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_revhistory *arg1 = (struct _dwg_revhistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_revhistory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_RevHistory" "', argument " "1"" of type '" "struct _dwg_revhistory *""'"); 
  }
  arg1 = (struct _dwg_revhistory *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_RevHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_revhistory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_RevHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_zero_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_zero_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_zero_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_zero_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->zero = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_zero_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_zero_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->zero);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_numhandles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_numhandles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_numhandles_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_numhandles_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->numhandles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_numhandles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_numhandles_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->numhandles);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_TDUPDATE_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_TIMERLL *arg2 = (BITCODE_TIMERLL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_TDUPDATE_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_TDUPDATE_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_ObjFreeSpace_TDUPDATE_set" "', argument " "2"" of type '" "BITCODE_TIMERLL *""'"); 
  }
  arg2 = (BITCODE_TIMERLL *)(argp2);
  if (arg1) (arg1)->TDUPDATE = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_TDUPDATE_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TIMERLL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_TDUPDATE_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_TIMERLL *)& ((arg1)->TDUPDATE);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_time_bll, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_objects_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_objects_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_objects_address_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_objects_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->objects_address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_objects_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_objects_address_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RL) ((arg1)->objects_address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_numnums_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_numnums_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_numnums_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_numnums_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->numnums = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_numnums_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_numnums_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RC) ((arg1)->numnums);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max32_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_max32_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max32_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_max32_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->max32 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max32_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max32_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->max32);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max64_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_max64_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max64_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_max64_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->max64 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max64_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max64_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->max64);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxtbl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_maxtbl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxtbl_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_maxtbl_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->maxtbl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxtbl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxtbl_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->maxtbl);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_maxrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxrl_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_maxrl_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->maxrl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxrl_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->maxrl);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max32_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_max32_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max32_hi_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_max32_hi_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->max32_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max32_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max32_hi_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->max32_hi);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max64_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_max64_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max64_hi_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_max64_hi_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->max64_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_max64_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_max64_hi_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->max64_hi);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxtbl_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_maxtbl_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxtbl_hi_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_maxtbl_hi_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->maxtbl_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxtbl_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxtbl_hi_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->maxtbl_hi);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxrl_hi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_ObjFreeSpace_maxrl_hi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxrl_hi_set" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_ObjFreeSpace_maxrl_hi_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->maxrl_hi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_ObjFreeSpace_maxrl_hi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_ObjFreeSpace_maxrl_hi_get" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  result = (BITCODE_RLL) ((arg1)->maxrl_hi);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_ObjFreeSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_ObjFreeSpace", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_objfreespace *)calloc(1, sizeof(struct _dwg_objfreespace));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_objfreespace, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_ObjFreeSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_objfreespace *arg1 = (struct _dwg_objfreespace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_objfreespace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_ObjFreeSpace" "', argument " "1"" of type '" "struct _dwg_objfreespace *""'"); 
  }
  arg1 = (struct _dwg_objfreespace *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_ObjFreeSpace_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_objfreespace, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_ObjFreeSpace_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Template_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *arg1 = (struct _dwg_template *) 0 ;
  BITCODE_TV arg2 = (BITCODE_TV) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Template_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_template, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Template_description_set" "', argument " "1"" of type '" "struct _dwg_template *""'"); 
  }
  arg1 = (struct _dwg_template *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Template_description_set" "', argument " "2"" of type '" "BITCODE_TV""'");
  }
  arg2 = (BITCODE_TV)(buf2);
  free((char*)arg1->description);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->description = (BITCODE_TV)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->description = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Template_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *arg1 = (struct _dwg_template *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_TV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_template, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Template_description_get" "', argument " "1"" of type '" "struct _dwg_template *""'"); 
  }
  arg1 = (struct _dwg_template *)(argp1);
  result = (BITCODE_TV) ((arg1)->description);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Template_MEASUREMENT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *arg1 = (struct _dwg_template *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Template_MEASUREMENT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_template, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Template_MEASUREMENT_set" "', argument " "1"" of type '" "struct _dwg_template *""'"); 
  }
  arg1 = (struct _dwg_template *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Template_MEASUREMENT_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->MEASUREMENT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Template_MEASUREMENT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *arg1 = (struct _dwg_template *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_template, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Template_MEASUREMENT_get" "', argument " "1"" of type '" "struct _dwg_template *""'"); 
  }
  arg1 = (struct _dwg_template *)(argp1);
  result = (BITCODE_RS) ((arg1)->MEASUREMENT);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Template(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Template", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_template *)calloc(1, sizeof(struct _dwg_template));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_template, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Template(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_template *arg1 = (struct _dwg_template *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_template, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Template" "', argument " "1"" of type '" "struct _dwg_template *""'"); 
  }
  arg1 = (struct _dwg_template *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Template_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_template, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Template_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_nr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Sections_nr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_nr_set" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_Sections_nr_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->nr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_nr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_nr_get" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  result = (BITCODE_RCd) ((arg1)->nr);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Sections_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_address_set" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_Sections_address_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_address_get" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  result = (BITCODE_BL) ((arg1)->address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Sections_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_size_set" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_Sections_size_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Sections_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Sections_size_get" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  result = (BITCODE_BL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SecondHeader_Sections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SecondHeader_Sections", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_secondheader_sections *)calloc(1, sizeof(struct _dwg_secondheader_sections));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader_sections, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SecondHeader_Sections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_sections *arg1 = (struct _dwg_secondheader_sections *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_sections, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SecondHeader_Sections" "', argument " "1"" of type '" "struct _dwg_secondheader_sections *""'"); 
  }
  arg1 = (struct _dwg_secondheader_sections *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SecondHeader_Sections_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_secondheader_sections, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SecondHeader_Sections_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_num_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Handles_num_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_num_hdl_set" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_Handles_num_hdl_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->num_hdl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_num_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_num_hdl_get" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  result = (BITCODE_RCd) ((arg1)->num_hdl);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_nr_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  BITCODE_RCd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Handles_nr_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_nr_set" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_Handles_nr_set" "', argument " "2"" of type '" "BITCODE_RCd""'");
  } 
  arg2 = (BITCODE_RCd)(val2);
  if (arg1) (arg1)->nr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_nr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RCd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_nr_get" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  result = (BITCODE_RCd) ((arg1)->nr);
  resultobj = SWIG_From_signed_SS_char((signed char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Handles_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_hdl_set" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SecondHeader_Handles_hdl_set" "', argument " "2"" of type '" "BITCODE_RC [8]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(BITCODE_RC *)&arg1->hdl[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""hdl""' of type '""BITCODE_RC [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_hdl_get" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->hdl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_Handles_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_name_set" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SecondHeader_Handles_name_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (arg2) {
    size_t size = strlen((const char *)((const char *)(arg2))) + 1;
    arg1->name = (char const *)(char *)memcpy(malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_Handles_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_Handles_name_get" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  result = (char *) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SecondHeader_Handles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SecondHeader_Handles", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_secondheader_handles *)calloc(1, sizeof(struct _dwg_secondheader_handles));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader_handles, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SecondHeader_Handles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader_handles *arg1 = (struct _dwg_secondheader_handles *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader_handles, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SecondHeader_Handles" "', argument " "1"" of type '" "struct _dwg_secondheader_handles *""'"); 
  }
  arg1 = (struct _dwg_secondheader_handles *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SecondHeader_Handles_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_secondheader_handles, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SecondHeader_Handles_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_size_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_size_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_size_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_address_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_address_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_address_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_address_set" "', argument " "2"" of type '" "BITCODE_RL""'");
  } 
  arg2 = (BITCODE_RL)(val2);
  if (arg1) (arg1)->address = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_address_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_address_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RL) ((arg1)->address);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) (BITCODE_RC *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_version_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SecondHeader_version_set" "', argument " "2"" of type '" "BITCODE_RC [11]""'"); 
  } 
  arg2 = (BITCODE_RC *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)11; ++ii) *(BITCODE_RC *)&arg1->version[ii] = *((BITCODE_RC *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""version""' of type '""BITCODE_RC [11]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_version_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RC *)(BITCODE_RC *) ((arg1)->version);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_is_maint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_is_maint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_is_maint_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_is_maint_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->is_maint = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_is_maint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_is_maint_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RC) ((arg1)->is_maint);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_zero_one_or_three_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_zero_one_or_three_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_zero_one_or_three_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_zero_one_or_three_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->zero_one_or_three = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_zero_one_or_three_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_zero_one_or_three_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RC) ((arg1)->zero_one_or_three);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_dwg_versions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_dwg_versions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_dwg_versions_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_dwg_versions_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->dwg_versions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_dwg_versions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_dwg_versions_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_BS) ((arg1)->dwg_versions);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_codepage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_codepage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_codepage_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_codepage_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->codepage = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_codepage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_codepage_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->codepage);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_num_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RC arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_num_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_num_sections_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_num_sections_set" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  if (arg1) (arg1)->num_sections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_num_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RC result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_num_sections_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RC) ((arg1)->num_sections);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_sections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  Dwg_SecondHeader_Sections *arg2 = (Dwg_SecondHeader_Sections *) (Dwg_SecondHeader_Sections *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_sections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_sections_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SecondHeader_sections_set" "', argument " "2"" of type '" "Dwg_SecondHeader_Sections [7]""'"); 
  } 
  arg2 = (Dwg_SecondHeader_Sections *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(Dwg_SecondHeader_Sections *)&arg1->sections[ii] = *((Dwg_SecondHeader_Sections *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""sections""' of type '""Dwg_SecondHeader_Sections [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_sections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SecondHeader_Sections *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_sections_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (Dwg_SecondHeader_Sections *)(Dwg_SecondHeader_Sections *) ((arg1)->sections);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader_sections, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_num_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_num_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_num_handles_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_num_handles_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_handles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_num_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_num_handles_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_handles);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_handles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  Dwg_SecondHeader_Handles *arg2 = (Dwg_SecondHeader_Handles *) (Dwg_SecondHeader_Handles *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_handles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_handles_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_SecondHeader_handles_set" "', argument " "2"" of type '" "Dwg_SecondHeader_Handles [14]""'"); 
  } 
  arg2 = (Dwg_SecondHeader_Handles *)(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)14; ++ii) *(Dwg_SecondHeader_Handles *)&arg1->handles[ii] = *((Dwg_SecondHeader_Handles *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""handles""' of type '""Dwg_SecondHeader_Handles [14]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_handles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SecondHeader_Handles *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_handles_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (Dwg_SecondHeader_Handles *)(Dwg_SecondHeader_Handles *) ((arg1)->handles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader_handles, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_crc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_crc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_crc_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_crc_set" "', argument " "2"" of type '" "BITCODE_RS""'");
  } 
  arg2 = (BITCODE_RS)(val2);
  if (arg1) (arg1)->crc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_crc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_crc_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RS) ((arg1)->crc);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_junk_r14_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_SecondHeader_junk_r14_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_junk_r14_set" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_SecondHeader_junk_r14_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->junk_r14 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_SecondHeader_junk_r14_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_SecondHeader_junk_r14_get" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  result = (BITCODE_RLL) ((arg1)->junk_r14);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_SecondHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_SecondHeader", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_secondheader *)calloc(1, sizeof(struct _dwg_secondheader));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_SecondHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_secondheader *arg1 = (struct _dwg_secondheader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_secondheader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_SecondHeader" "', argument " "1"" of type '" "struct _dwg_secondheader *""'"); 
  }
  arg1 = (struct _dwg_secondheader *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_SecondHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_secondheader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_SecondHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Dwg_Data_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Header *arg2 = (Dwg_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_header_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_header, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_header_set" "', argument " "2"" of type '" "Dwg_Header *""'"); 
  }
  arg2 = (Dwg_Header *)(argp2);
  if (arg1) (arg1)->header = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Header *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_header_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Header *)& ((arg1)->header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_classes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BS arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_classes_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_classes_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_classes_set" "', argument " "2"" of type '" "BITCODE_BS""'");
  } 
  arg2 = (BITCODE_BS)(val2);
  if (arg1) (arg1)->num_classes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_classes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_classes_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BS) ((arg1)->num_classes);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_dwg_class_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Class *arg2 = (Dwg_Class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_dwg_class_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_dwg_class_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_class, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_dwg_class_set" "', argument " "2"" of type '" "Dwg_Class *""'"); 
  }
  arg2 = (Dwg_Class *)(argp2);
  if (arg1) (arg1)->dwg_class = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_dwg_class_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Class *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_dwg_class_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Class *) ((arg1)->dwg_class);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_class, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_objects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_objects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_objects_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_objects_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_objects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_objects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_objects_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_objects);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_alloced_objects_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_alloced_objects_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_alloced_objects_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_alloced_objects_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_alloced_objects = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_alloced_objects_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_alloced_objects_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_alloced_objects);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_object_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_object_set" "', argument " "2"" of type '" "Dwg_Object *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  if (arg1) (arg1)->object = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object *) ((arg1)->object);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_entities_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_entities_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_entities_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_entities_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_entities = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_entities_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_entities_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_entities);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_object_refs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_object_refs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_object_refs_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_object_refs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_object_refs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_object_refs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_object_refs_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_object_refs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_cur_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_cur_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_cur_index_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_cur_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->cur_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_cur_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_cur_index_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->cur_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object_Ref **arg2 = (Dwg_Object_Ref **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_object_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_ref_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_object_ref_set" "', argument " "2"" of type '" "Dwg_Object_Ref **""'"); 
  }
  arg2 = (Dwg_Object_Ref **)(argp2);
  if (arg1) (arg1)->object_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Ref **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_ref_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object_Ref **) ((arg1)->object_ref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  struct _inthash *arg2 = (struct _inthash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_object_map_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_map_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__inthash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_object_map_set" "', argument " "2"" of type '" "struct _inthash *""'"); 
  }
  arg2 = (struct _inthash *)(argp2);
  if (arg1) (arg1)->object_map = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct _inthash *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_map_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (struct _inthash *) ((arg1)->object_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__inthash, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_dirty_refs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_dirty_refs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_dirty_refs_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_dirty_refs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->dirty_refs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_dirty_refs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_dirty_refs_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (int) ((arg1)->dirty_refs);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_opts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_opts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_opts_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_opts_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->opts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_opts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_opts_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (unsigned int) ((arg1)->opts);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_header_vars_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Header_Variables *arg2 = (Dwg_Header_Variables *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_header_vars_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_header_vars_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_header_vars_set" "', argument " "2"" of type '" "Dwg_Header_Variables *""'"); 
  }
  arg2 = (Dwg_Header_Variables *)(argp2);
  if (arg1) (arg1)->header_vars = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_header_vars_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Header_Variables *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_header_vars_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Header_Variables *)& ((arg1)->header_vars);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_header_variables, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_thumbnail_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Chain *arg2 = (Dwg_Chain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_thumbnail_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_thumbnail_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_chain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_thumbnail_set" "', argument " "2"" of type '" "Dwg_Chain *""'"); 
  }
  arg2 = (Dwg_Chain *)(argp2);
  if (arg1) (arg1)->thumbnail = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_thumbnail_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Chain *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_thumbnail_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Chain *)& ((arg1)->thumbnail);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_chain, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_fhdr_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  _dwg_struct_fhdr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_fhdr_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (_dwg_struct_fhdr *)& ((arg1)->fhdr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct_fhdr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_mspace_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_mspace_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_mspace_block_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_mspace_block_set" "', argument " "2"" of type '" "Dwg_Object *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  if (arg1) (arg1)->mspace_block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_mspace_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_mspace_block_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object *) ((arg1)->mspace_block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_pspace_block_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_pspace_block_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_pspace_block_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_pspace_block_set" "', argument " "2"" of type '" "Dwg_Object *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  if (arg1) (arg1)->pspace_block = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_pspace_block_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_pspace_block_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object *) ((arg1)->pspace_block);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_block_control_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object_BLOCK_CONTROL *arg2 = (Dwg_Object_BLOCK_CONTROL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_block_control_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_block_control_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_block_control_set" "', argument " "2"" of type '" "Dwg_Object_BLOCK_CONTROL *""'"); 
  }
  arg2 = (Dwg_Object_BLOCK_CONTROL *)(argp2);
  if (arg1) (arg1)->block_control = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_block_control_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_block_control_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object_BLOCK_CONTROL *)& ((arg1)->block_control);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_auxheader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_AuxHeader *arg2 = (Dwg_AuxHeader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_auxheader_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_auxheader_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_auxheader_set" "', argument " "2"" of type '" "Dwg_AuxHeader *""'"); 
  }
  arg2 = (Dwg_AuxHeader *)(argp2);
  if (arg1) (arg1)->auxheader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_auxheader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AuxHeader *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_auxheader_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_AuxHeader *)& ((arg1)->auxheader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_auxheader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_secondheader_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_SecondHeader *arg2 = (Dwg_SecondHeader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_secondheader_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_secondheader_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_secondheader_set" "', argument " "2"" of type '" "Dwg_SecondHeader *""'"); 
  }
  arg2 = (Dwg_SecondHeader *)(argp2);
  if (arg1) (arg1)->secondheader = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_secondheader_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SecondHeader *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_secondheader_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_SecondHeader *)& ((arg1)->secondheader);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_secondheader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_summaryinfo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_SummaryInfo *arg2 = (Dwg_SummaryInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_summaryinfo_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_summaryinfo_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_summaryinfo_set" "', argument " "2"" of type '" "Dwg_SummaryInfo *""'"); 
  }
  arg2 = (Dwg_SummaryInfo *)(argp2);
  if (arg1) (arg1)->summaryinfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_summaryinfo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_SummaryInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_summaryinfo_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_SummaryInfo *)& ((arg1)->summaryinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_summaryinfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_appinfo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_AppInfo *arg2 = (Dwg_AppInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_appinfo_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_appinfo_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_appinfo_set" "', argument " "2"" of type '" "Dwg_AppInfo *""'"); 
  }
  arg2 = (Dwg_AppInfo *)(argp2);
  if (arg1) (arg1)->appinfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_appinfo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AppInfo *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_appinfo_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_AppInfo *)& ((arg1)->appinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_appinfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_filedeplist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_FileDepList *arg2 = (Dwg_FileDepList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_filedeplist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_filedeplist_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_filedeplist_set" "', argument " "2"" of type '" "Dwg_FileDepList *""'"); 
  }
  arg2 = (Dwg_FileDepList *)(argp2);
  if (arg1) (arg1)->filedeplist = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_filedeplist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_FileDepList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_filedeplist_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_FileDepList *)& ((arg1)->filedeplist);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_filedeplist, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_security_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Security *arg2 = (Dwg_Security *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_security_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_security_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_security, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_security_set" "', argument " "2"" of type '" "Dwg_Security *""'"); 
  }
  arg2 = (Dwg_Security *)(argp2);
  if (arg1) (arg1)->security = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_security_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Security *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_security_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Security *)& ((arg1)->security);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_security, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_vbaproject_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_VBAProject *arg2 = (Dwg_VBAProject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_vbaproject_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_vbaproject_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_vbaproject_set" "', argument " "2"" of type '" "Dwg_VBAProject *""'"); 
  }
  arg2 = (Dwg_VBAProject *)(argp2);
  if (arg1) (arg1)->vbaproject = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_vbaproject_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_VBAProject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_vbaproject_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_VBAProject *)& ((arg1)->vbaproject);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_vbaproject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_appinfohistory_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_AppInfoHistory *arg2 = (Dwg_AppInfoHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_appinfohistory_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_appinfohistory_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_appinfohistory_set" "', argument " "2"" of type '" "Dwg_AppInfoHistory *""'"); 
  }
  arg2 = (Dwg_AppInfoHistory *)(argp2);
  if (arg1) (arg1)->appinfohistory = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_appinfohistory_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AppInfoHistory *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_appinfohistory_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_AppInfoHistory *)& ((arg1)->appinfohistory);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_appinfohistory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_revhistory_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_RevHistory *arg2 = (Dwg_RevHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_revhistory_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_revhistory_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_revhistory_set" "', argument " "2"" of type '" "Dwg_RevHistory *""'"); 
  }
  arg2 = (Dwg_RevHistory *)(argp2);
  if (arg1) (arg1)->revhistory = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_revhistory_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_RevHistory *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_revhistory_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_RevHistory *)& ((arg1)->revhistory);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_revhistory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_objfreespace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_ObjFreeSpace *arg2 = (Dwg_ObjFreeSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_objfreespace_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_objfreespace_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_objfreespace_set" "', argument " "2"" of type '" "Dwg_ObjFreeSpace *""'"); 
  }
  arg2 = (Dwg_ObjFreeSpace *)(argp2);
  if (arg1) (arg1)->objfreespace = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_objfreespace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_ObjFreeSpace *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_objfreespace_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_ObjFreeSpace *)& ((arg1)->objfreespace);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_objfreespace, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_Template_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Template *arg2 = (Dwg_Template *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_Template_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_Template_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_template, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_Template_set" "', argument " "2"" of type '" "Dwg_Template *""'"); 
  }
  arg2 = (Dwg_Template *)(argp2);
  if (arg1) (arg1)->Template = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_Template_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Template *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_Template_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Template *)& ((arg1)->Template);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_template, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_acds_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_AcDs *arg2 = (Dwg_AcDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_acds_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_acds_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_acds_set" "', argument " "2"" of type '" "Dwg_AcDs *""'"); 
  }
  arg2 = (Dwg_AcDs *)(argp2);
  if (arg1) (arg1)->acds = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_acds_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_AcDs *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_acds_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_AcDs *)& ((arg1)->acds);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_AcDs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_layout_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_layout_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_layout_type_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_layout_type_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->layout_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_layout_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_layout_type_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (unsigned int) ((arg1)->layout_type);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_acis_sab_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_acis_sab_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_acis_sab_hdl_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_acis_sab_hdl_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->num_acis_sab_hdl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_acis_sab_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_acis_sab_hdl_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (unsigned int) ((arg1)->num_acis_sab_hdl);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_acis_sab_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_H *arg2 = (BITCODE_H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_acis_sab_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_acis_sab_hdl_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_acis_sab_hdl_set" "', argument " "2"" of type '" "BITCODE_H *""'"); 
  }
  arg2 = (BITCODE_H *)(argp2);
  if (arg1) (arg1)->acis_sab_hdl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_acis_sab_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_H *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_acis_sab_hdl_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_H *) ((arg1)->acis_sab_hdl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_next_hdl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_RLL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_next_hdl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_next_hdl_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_next_hdl_set" "', argument " "2"" of type '" "BITCODE_RLL""'");
  } 
  arg2 = (BITCODE_RLL)(val2);
  if (arg1) (arg1)->next_hdl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_next_hdl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_RLL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_next_hdl_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_RLL) ((arg1)->next_hdl);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_prev_entity_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_prev_entity_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_prev_entity_index_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_prev_entity_index_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->prev_entity_index = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_prev_entity_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_prev_entity_index_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->prev_entity_index);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_ordered_ref_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  Dwg_Object_Ref **arg2 = (Dwg_Object_Ref **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_object_ordered_ref_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_ordered_ref_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dwg_Data_object_ordered_ref_set" "', argument " "2"" of type '" "Dwg_Object_Ref **""'"); 
  }
  arg2 = (Dwg_Object_Ref **)(argp2);
  if (arg1) (arg1)->object_ordered_ref = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_object_ordered_ref_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Ref **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_object_ordered_ref_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (Dwg_Object_Ref **) ((arg1)->object_ordered_ref);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_object_ordered_refs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_Data_num_object_ordered_refs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_object_ordered_refs_set" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_Data_num_object_ordered_refs_set" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  if (arg1) (arg1)->num_object_ordered_refs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_Data_num_object_ordered_refs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_Data_num_object_ordered_refs_get" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  result = (BITCODE_BL) ((arg1)->num_object_ordered_refs);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_Data", 0, 0, 0)) SWIG_fail;
  result = (struct _dwg_struct *)calloc(1, sizeof(struct _dwg_struct));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct _dwg_struct *arg1 = (struct _dwg_struct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_Data" "', argument " "1"" of type '" "struct _dwg_struct *""'"); 
  }
  arg1 = (struct _dwg_struct *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_Data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_struct, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_Data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__dwg_struct_fhdr_r2004_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *arg1 = (_dwg_struct_fhdr *) 0 ;
  Dwg_R2004_Header *arg2 = (Dwg_R2004_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_struct_fhdr_r2004_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct_fhdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_struct_fhdr_r2004_header_set" "', argument " "1"" of type '" "_dwg_struct_fhdr *""'"); 
  }
  arg1 = (_dwg_struct_fhdr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_struct_fhdr_r2004_header_set" "', argument " "2"" of type '" "Dwg_R2004_Header *""'"); 
  }
  arg2 = (Dwg_R2004_Header *)(argp2);
  if (arg1) (arg1)->r2004_header = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_struct_fhdr_r2004_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *arg1 = (_dwg_struct_fhdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_R2004_Header *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct_fhdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_struct_fhdr_r2004_header_get" "', argument " "1"" of type '" "_dwg_struct_fhdr *""'"); 
  }
  arg1 = (_dwg_struct_fhdr *)(argp1);
  result = (Dwg_R2004_Header *)& ((arg1)->r2004_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_R2004_Header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_struct_fhdr_r2007_file_header_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *arg1 = (_dwg_struct_fhdr *) 0 ;
  Dwg_R2007_Header *arg2 = (Dwg_R2007_Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_dwg_struct_fhdr_r2007_file_header_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct_fhdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_struct_fhdr_r2007_file_header_set" "', argument " "1"" of type '" "_dwg_struct_fhdr *""'"); 
  }
  arg1 = (_dwg_struct_fhdr *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_r2007_file_header, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_dwg_struct_fhdr_r2007_file_header_set" "', argument " "2"" of type '" "Dwg_R2007_Header *""'"); 
  }
  arg2 = (Dwg_R2007_Header *)(argp2);
  if (arg1) (arg1)->r2007_file_header = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__dwg_struct_fhdr_r2007_file_header_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *arg1 = (_dwg_struct_fhdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_R2007_Header *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct_fhdr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_dwg_struct_fhdr_r2007_file_header_get" "', argument " "1"" of type '" "_dwg_struct_fhdr *""'"); 
  }
  arg1 = (_dwg_struct_fhdr *)(argp1);
  result = (Dwg_R2007_Header *)& ((arg1)->r2007_file_header);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_r2007_file_header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__dwg_struct_fhdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__dwg_struct_fhdr", 0, 0, 0)) SWIG_fail;
  result = (_dwg_struct_fhdr *)calloc(1, sizeof(_dwg_struct_fhdr));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_struct_fhdr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__dwg_struct_fhdr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _dwg_struct_fhdr *arg1 = (_dwg_struct_fhdr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct_fhdr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__dwg_struct_fhdr" "', argument " "1"" of type '" "_dwg_struct_fhdr *""'"); 
  }
  arg1 = (_dwg_struct_fhdr *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_dwg_struct_fhdr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__dwg_struct_fhdr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_dwg_struct_fhdr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_dwg_read_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  Dwg_Data *arg2 = (Dwg_Data *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_read_file", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_read_file" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_read_file" "', argument " "2"" of type '" "Dwg_Data *""'"); 
  }
  arg2 = (Dwg_Data *)(argp2);
  result = (int)dwg_read_file((char const *)arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dxf_read_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  Dwg_Data *arg2 = (Dwg_Data *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dxf_read_file", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dxf_read_file" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dxf_read_file" "', argument " "2"" of type '" "Dwg_Data *""'"); 
  }
  arg2 = (Dwg_Data *)(argp2);
  result = (int)dxf_read_file((char const *)arg1,arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_write_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  Dwg_Data *arg2 = (Dwg_Data *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_write_file", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_write_file" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_write_file" "', argument " "2"" of type '" "Dwg_Data const *""'"); 
  }
  arg2 = (Dwg_Data *)(argp2);
  result = (int)dwg_write_file((char const *)arg1,(struct _dwg_struct const *)arg2);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_bmp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_RL *arg2 = (BITCODE_RL *) 0 ;
  BITCODE_RC *arg3 = (BITCODE_RC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_bmp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_bmp" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_bmp" "', argument " "2"" of type '" "BITCODE_RL *""'"); 
  }
  arg2 = (BITCODE_RL *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_bmp" "', argument " "3"" of type '" "BITCODE_RC *""'"); 
  }
  arg3 = (BITCODE_RC *)(argp3);
  result = (unsigned char *)dwg_bmp((struct _dwg_struct const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dxf_cvt_lweight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BITCODE_BSd arg1 ;
  short val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dxf_cvt_lweight" "', argument " "1"" of type '" "BITCODE_BSd""'");
  } 
  arg1 = (BITCODE_BSd)(val1);
  result = (int)dxf_cvt_lweight(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dxf_revcvt_lweight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BSd result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dxf_revcvt_lweight" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  result = (BITCODE_BSd)dxf_revcvt_lweight(arg1);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ctrl_table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ctrl_table", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ctrl_table" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ctrl_table" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (BITCODE_H)dwg_ctrl_table(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_tablehandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_tablehandle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_tablehandle" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_tablehandle" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_find_tablehandle" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  result = (BITCODE_H)dwg_find_tablehandle(arg1,(char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_tablehandle_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_tablehandle_index", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_tablehandle_index" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_find_tablehandle_index" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_find_tablehandle_index" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  result = (BITCODE_H)dwg_find_tablehandle_index(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_handle_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  BITCODE_H arg3 = (BITCODE_H) (BITCODE_H)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_handle_name", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_handle_name" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_handle_name" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_handle_name" "', argument " "3"" of type '" "BITCODE_H const""'"); 
  }
  arg3 = (BITCODE_H)(argp3);
  result = (char *)dwg_handle_name(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_table_control(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_table_control", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_table_control" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_table_control" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (BITCODE_H)dwg_find_table_control(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_dictionary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_dictionary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_dictionary" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_dictionary" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (BITCODE_H)dwg_find_dictionary(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_dicthandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_dicthandle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_dicthandle" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_dicthandle" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_find_dicthandle" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  result = (BITCODE_H)dwg_find_dicthandle(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_dicthandle_objname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_H arg2 = (BITCODE_H) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  BITCODE_H result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_dicthandle_objname", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_dicthandle_objname" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_dicthandle_objname" "', argument " "2"" of type '" "BITCODE_H""'"); 
  }
  arg2 = (BITCODE_H)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_find_dicthandle_objname" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  result = (BITCODE_H)dwg_find_dicthandle_objname(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_table_extname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_find_table_extname", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_find_table_extname" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_find_table_extname" "', argument " "2"" of type '" "Dwg_Object *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (char *)dwg_find_table_extname(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_variable_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_variable_dict", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_variable_dict" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_variable_dict" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (char *)dwg_variable_dict(arg1,(char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_x_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_x_min" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_x_min((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_x_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_x_max" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_x_max((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_y_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_y_min" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_y_min((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_y_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_y_max" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_y_max((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_z_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_z_min" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_z_min((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_z_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_z_max" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_model_z_max((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_page_x_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_page_x_min" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_page_x_min((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_page_x_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_page_x_max" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_page_x_max((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_page_y_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_page_y_min" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_page_y_min((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_page_y_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_page_y_max" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (double)dwg_page_y_max((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_block_control(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_block_control" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCK_CONTROL *)dwg_block_control(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_space_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_space_ref" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_Ref *)dwg_model_space_ref(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_paper_space_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_paper_space_ref" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_Ref *)dwg_paper_space_ref(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_model_space_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_model_space_object" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object *)dwg_model_space_object(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_paper_space_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_paper_space_object" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object *)dwg_paper_space_object(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_layer_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_layer_count" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (unsigned int)dwg_get_layer_count((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_layers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_layers" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYER **)dwg_get_layers((struct _dwg_struct const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_num_objects(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_num_objects" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (BITCODE_BL)dwg_get_num_objects((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_object_num_objects(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_object_num_objects" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (BITCODE_BL)dwg_get_object_num_objects((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_class_is_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Class *arg1 = (Dwg_Class *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_class, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_class_is_entity" "', argument " "1"" of type '" "Dwg_Class const *""'"); 
  }
  arg1 = (Dwg_Class *)(argp1);
  result = (int)dwg_class_is_entity((struct _dwg_class const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_is_control(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_is_control" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_is_control((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_is_table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_is_table" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_is_table((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_is_subentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_is_subentity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_is_subentity((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_has_subentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_has_subentity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_has_subentity((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_is_3dsolid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_is_3dsolid" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_is_3dsolid((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_is_acsh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_is_acsh" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_obj_is_acsh((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_num_entities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_num_entities" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (BITCODE_BL)dwg_get_num_entities((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_entities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Entity **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_entities" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_Entity **)dwg_get_entities((struct _dwg_struct const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_entity_layer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Entity *arg1 = (Dwg_Object_Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_entity_layer" "', argument " "1"" of type '" "Dwg_Object_Entity const *""'"); 
  }
  arg1 = (Dwg_Object_Entity *)(argp1);
  result = (Dwg_Object_LAYER *)dwg_get_entity_layer((struct _dwg_object_entity const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_next_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_next_object" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)dwg_next_object((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_next_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_next_entity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)dwg_next_entity((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_next_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_HV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_next_handle" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (BITCODE_HV)dwg_next_handle((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_next_handseed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_HV result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_next_handseed" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (BITCODE_HV)dwg_next_handseed(arg1);
  resultobj = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Ref *arg2 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_object" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_object" "', argument " "2"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg2 = (Dwg_Object_Ref *)(argp2);
  result = (Dwg_Object *)dwg_ref_object(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_object_relative(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Ref *arg2 = (Dwg_Object_Ref *) 0 ;
  Dwg_Object *arg3 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_object_relative", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_object_relative" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_object_relative" "', argument " "2"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg2 = (Dwg_Object_Ref *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_ref_object_relative" "', argument " "3"" of type '" "Dwg_Object const *""'"); 
  }
  arg3 = (Dwg_Object *)(argp3);
  result = (Dwg_Object *)dwg_ref_object_relative(arg1,arg2,(struct _dwg_object const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_object_silent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Ref *arg2 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_object_silent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_object_silent" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_object_silent" "', argument " "2"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg2 = (Dwg_Object_Ref *)(argp2);
  result = (Dwg_Object *)dwg_ref_object_silent(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_first_owned_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_first_owned_entity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)get_first_owned_entity((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_next_owned_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "get_next_owned_entity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_next_owned_entity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_next_owned_entity" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (Dwg_Object *)get_next_owned_entity((struct _dwg_object const *)arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_first_owned_subentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_first_owned_subentity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)get_first_owned_subentity((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_next_owned_subentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "get_next_owned_subentity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_next_owned_subentity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_next_owned_subentity" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (Dwg_Object *)get_next_owned_subentity((struct _dwg_object const *)arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_first_owned_block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_first_owned_block" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)get_first_owned_block((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_last_owned_block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_last_owned_block" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)get_last_owned_block((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_next_owned_block(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "get_next_owned_block", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_next_owned_block" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_next_owned_block" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (Dwg_Object *)get_next_owned_block((struct _dwg_object const *)arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_next_owned_block_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "get_next_owned_block_entity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_next_owned_block_entity" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_next_owned_block_entity" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (Dwg_Object *)get_next_owned_block_entity((struct _dwg_object const *)arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_first_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_get_first_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_first_object" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_get_first_object" "', argument " "2"" of type '" "Dwg_Object_Type""'");
  } 
  arg2 = (Dwg_Object_Type)(val2);
  result = (Dwg_Object *)dwg_get_first_object((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_next_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Type arg2 ;
  BITCODE_RL arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_get_next_object", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_next_object" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_get_next_object" "', argument " "2"" of type '" "Dwg_Object_Type""'");
  } 
  arg2 = (Dwg_Object_Type)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dwg_get_next_object" "', argument " "3"" of type '" "BITCODE_RL""'");
  } 
  arg3 = (BITCODE_RL)(val3);
  result = (Dwg_Object *)dwg_get_next_object((struct _dwg_struct const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_resolve_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_HV arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_resolve_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_resolve_handle" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_resolve_handle" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  result = (Dwg_Object *)dwg_resolve_handle((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_resolve_handle_silent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_HV arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_resolve_handle_silent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_resolve_handle_silent" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_resolve_handle_silent" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  result = (Dwg_Object *)dwg_resolve_handle_silent((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_resolve_handleref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_resolve_handleref", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_resolve_handleref" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_resolve_handleref" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (int)dwg_resolve_handleref(arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_resolve_jump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_resolve_jump" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object *)dwg_resolve_jump((struct _dwg_object const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_section_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_section_type" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_Section_Type)dwg_section_type((char const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_section_wtype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_wchar_t *arg1 = (dwg_wchar_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Section_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_section_wtype" "', argument " "1"" of type '" "dwg_wchar_t const *""'"); 
  }
  arg1 = (dwg_wchar_t *)(argp1);
  result = (Dwg_Section_Type)dwg_section_wtype((unsigned short const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_section_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_section_name", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_section_name" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_section_name" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  result = (char *)dwg_section_name((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_resbuf_value_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  short arg1 ;
  short val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  enum RESBUF_VALUE_TYPE result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_resbuf_value_type" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = (short)(val1);
  result = (enum RESBUF_VALUE_TYPE)dwg_resbuf_value_type(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_free(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_free" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  dwg_free(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_free_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_free_object" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  dwg_free_object(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_new_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_new_ref" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_Ref *)dwg_new_ref(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_add_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Handle *arg1 = (Dwg_Handle *) 0 ;
  BITCODE_RC arg2 ;
  BITCODE_HV arg3 ;
  Dwg_Object *arg4 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_add_handle", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_handle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_add_handle" "', argument " "1"" of type '" "Dwg_Handle *""'"); 
  }
  arg1 = (Dwg_Handle *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_add_handle" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dwg_add_handle" "', argument " "3"" of type '" "BITCODE_HV""'");
  } 
  arg3 = (BITCODE_HV)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_add_handle" "', argument " "4"" of type '" "Dwg_Object const *""'"); 
  }
  arg4 = (Dwg_Object *)(argp4);
  result = (int)dwg_add_handle(arg1,arg2,arg3,(struct _dwg_object const *)arg4);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_add_handleref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_RC arg2 ;
  BITCODE_HV arg3 ;
  Dwg_Object *arg4 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_add_handleref", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_add_handleref" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_add_handleref" "', argument " "2"" of type '" "BITCODE_RC""'");
  } 
  arg2 = (BITCODE_RC)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dwg_add_handleref" "', argument " "3"" of type '" "BITCODE_HV""'");
  } 
  arg3 = (BITCODE_HV)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_add_handleref" "', argument " "4"" of type '" "Dwg_Object const *""'"); 
  }
  arg4 = (Dwg_Object *)(argp4);
  result = (Dwg_Object_Ref *)dwg_add_handleref(arg1,arg2,arg3,(struct _dwg_object const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dup_handleref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Ref *arg2 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dup_handleref", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dup_handleref" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dup_handleref" "', argument " "2"" of type '" "Dwg_Object_Ref const *""'"); 
  }
  arg2 = (Dwg_Object_Ref *)(argp2);
  result = (Dwg_Object_Ref *)dwg_dup_handleref(arg1,(struct _dwg_object_ref const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_add_handleref_free(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BITCODE_RC arg1 ;
  BITCODE_HV arg2 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object_Ref *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_add_handleref_free", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_add_handleref_free" "', argument " "1"" of type '" "BITCODE_RC""'");
  } 
  arg1 = (BITCODE_RC)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_add_handleref_free" "', argument " "2"" of type '" "BITCODE_HV""'");
  } 
  arg2 = (BITCODE_HV)(val2);
  result = (Dwg_Object_Ref *)dwg_add_handleref_free(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_version_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Version_Type arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_version_type" "', argument " "1"" of type '" "Dwg_Version_Type""'");
  } 
  arg1 = (Dwg_Version_Type)(val1);
  result = (char *)dwg_version_type(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_version_as(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Version_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_version_as" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_Version_Type)dwg_version_as((char const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_version_hdr_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Version_Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_version_hdr_type" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_Version_Type)dwg_version_hdr_type((char const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_supports_eed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_supports_eed" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (int)dwg_supports_eed((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_supports_obj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object *arg2 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_supports_obj", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_supports_obj" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_supports_obj" "', argument " "2"" of type '" "Dwg_Object const *""'"); 
  }
  arg2 = (Dwg_Object *)(argp2);
  result = (int)dwg_supports_obj((struct _dwg_struct const *)arg1,(struct _dwg_object const *)arg2);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_errstrings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_errstrings" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  dwg_errstrings(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_encrypt_SAT1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BITCODE_BL arg1 ;
  BITCODE_RC *arg2 = (BITCODE_RC *) 0 ;
  int *arg3 = (int *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_encrypt_SAT1", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_encrypt_SAT1" "', argument " "1"" of type '" "BITCODE_BL""'");
  } 
  arg1 = (BITCODE_BL)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_encrypt_SAT1" "', argument " "2"" of type '" "BITCODE_RC *""'"); 
  }
  arg2 = (BITCODE_RC *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_encrypt_SAT1" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  result = (char *)dwg_encrypt_SAT1(arg1,arg2,arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_convert_SAB_to_SAT1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Entity__3DSOLID *arg1 = (Dwg_Entity__3DSOLID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_convert_SAB_to_SAT1" "', argument " "1"" of type '" "Dwg_Entity__3DSOLID *""'"); 
  }
  arg1 = (Dwg_Entity__3DSOLID *)(argp1);
  result = (int)dwg_convert_SAB_to_SAT1(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_r_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RGB_Palette_r_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_r_set" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RGB_Palette_r_set" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = (unsigned char)(val2);
  if (arg1) (arg1)->r = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_r_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_r_get" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  result = (unsigned char) ((arg1)->r);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_g_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RGB_Palette_g_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_g_set" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RGB_Palette_g_set" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = (unsigned char)(val2);
  if (arg1) (arg1)->g = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_g_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_g_get" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  result = (unsigned char) ((arg1)->g);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Dwg_RGB_Palette_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_b_set" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Dwg_RGB_Palette_b_set" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = (unsigned char)(val2);
  if (arg1) (arg1)->b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_RGB_Palette_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_RGB_Palette_b_get" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  result = (unsigned char) ((arg1)->b);
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_RGB_Palette(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_RGB_Palette", 0, 0, 0)) SWIG_fail;
  result = (struct rgbpalette *)calloc(1, sizeof(struct rgbpalette));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rgbpalette, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_RGB_Palette(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct rgbpalette *arg1 = (struct rgbpalette *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_rgbpalette, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_RGB_Palette" "', argument " "1"" of type '" "struct rgbpalette *""'"); 
  }
  arg1 = (struct rgbpalette *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_RGB_Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_rgbpalette, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_RGB_Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_dwg_rgb_palette(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_RGB_Palette *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_rgb_palette", 0, 0, 0)) SWIG_fail;
  result = (Dwg_RGB_Palette *)dwg_rgb_palette();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rgbpalette, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_rgb_palette_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BITCODE_BS arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_rgb_palette_index" "', argument " "1"" of type '" "BITCODE_BS""'");
  } 
  arg1 = (BITCODE_BS)(val1);
  result = (BITCODE_BL)dwg_rgb_palette_index(arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_find_color_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BITCODE_BL arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BITCODE_BS result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dwg_find_color_index" "', argument " "1"" of type '" "BITCODE_BL""'");
  } 
  arg1 = (BITCODE_BL)(val1);
  result = (BITCODE_BS)dwg_find_color_index(arg1);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_add_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_add_object" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (int)dwg_add_object(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) (char *)0 ;
  char **arg2 = (char **) 0 ;
  Dwg_Object_Type *arg3 = (Dwg_Object_Type *) 0 ;
  int *arg4 = (int *) 0 ;
  Dwg_Class_Stability *arg5 = (Dwg_Class_Stability *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_object_name", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_name" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_object_name" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = (char **)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_DWG_OBJECT_TYPE, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_object_name" "', argument " "3"" of type '" "Dwg_Object_Type *""'"); 
  }
  arg3 = (Dwg_Object_Type *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_object_name" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_DWG_CLASS_STABILITY, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_object_name" "', argument " "5"" of type '" "Dwg_Class_Stability *""'"); 
  }
  arg5 = (Dwg_Class_Stability *)(argp5);
  result = (int)dwg_object_name((char const *)arg1,(char const **)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup__3DFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup__3DFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup__3DFACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup__3DSOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup__3DSOLID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup__3DSOLID(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ARC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ARC" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ARC(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ATTDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ATTDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ATTDEF(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ATTRIB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ATTRIB" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ATTRIB(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCK(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_CIRCLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_CIRCLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_CIRCLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_ALIGNED(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_ALIGNED" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_ALIGNED(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_ANG2LN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_ANG2LN" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_ANG2LN(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_ANG3PT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_ANG3PT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_ANG3PT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_DIAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_DIAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_DIAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_LINEAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_LINEAR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_LINEAR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_ORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_ORDINATE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_ORDINATE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMENSION_RADIUS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMENSION_RADIUS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMENSION_RADIUS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ELLIPSE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ELLIPSE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ELLIPSE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ENDBLK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ENDBLK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ENDBLK(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_INSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_INSERT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_INSERT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LEADER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LOAD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LOAD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LOAD(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MINSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MINSERT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MINSERT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MLINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MTEXT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MTEXT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_OLEFRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_OLEFRAME" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_OLEFRAME(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POLYLINE_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POLYLINE_2D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POLYLINE_2D(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POLYLINE_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POLYLINE_3D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POLYLINE_3D(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POLYLINE_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POLYLINE_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POLYLINE_MESH(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POLYLINE_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POLYLINE_PFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POLYLINE_PFACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PROXY_ENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PROXY_ENTITY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PROXY_ENTITY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RAY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_REGION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_REGION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_REGION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SEQEND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SEQEND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SEQEND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SHAPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SHAPE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SHAPE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SOLID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SOLID(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SPLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SPLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SPLINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TEXT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TEXT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TOLERANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TOLERANCE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TOLERANCE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TRACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TRACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TRACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_UNKNOWN_ENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_UNKNOWN_ENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_UNKNOWN_ENT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VERTEX_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VERTEX_2D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VERTEX_2D(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VERTEX_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VERTEX_3D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VERTEX_3D(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VERTEX_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VERTEX_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VERTEX_MESH(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VERTEX_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VERTEX_PFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VERTEX_PFACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VERTEX_PFACE_FACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VERTEX_PFACE_FACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VERTEX_PFACE_FACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VIEWPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VIEWPORT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VIEWPORT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_XLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_XLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_XLINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_APPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_APPID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_APPID(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_APPID_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_APPID_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_APPID_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCK_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCK_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCK_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCK_HEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCK_HEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCK_HEADER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DICTIONARY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DICTIONARY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DICTIONARY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMSTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DIMSTYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DIMSTYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DIMSTYLE_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DUMMY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DUMMY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DUMMY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYER_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYER_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYER_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LONG_TRANSACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LONG_TRANSACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LONG_TRANSACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LTYPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LTYPE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LTYPE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LTYPE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LTYPE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LTYPE_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MLINESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MLINESTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MLINESTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_STYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_STYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_STYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_STYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_STYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_STYLE_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_UCS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_UCS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_UCS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_UCS_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_UCS_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_UCS_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_UNKNOWN_OBJ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_UNKNOWN_OBJ" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_UNKNOWN_OBJ(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VIEW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VIEW" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VIEW(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VIEW_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VIEW_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VIEW_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VPORT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VPORT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VPORT_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VPORT_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VPORT_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VX_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VX_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VX_CONTROL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VX_TABLE_RECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VX_TABLE_RECORD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VX_TABLE_RECORD(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup__3DLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup__3DLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup__3DLINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_CAMERA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_CAMERA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_CAMERA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DGNUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DGNUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DGNUNDERLAY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DWFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DWFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DWFUNDERLAY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ENDREP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ENDREP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ENDREP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_HATCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_HATCH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_HATCH(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IMAGE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IMAGE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_JUMP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_JUMP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LIGHT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LIGHT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LIGHT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LWPOLYLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LWPOLYLINE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MESH(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MULTILEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MULTILEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MULTILEADER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_OLE2FRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_OLE2FRAME" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_OLE2FRAME(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PDFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PDFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PDFUNDERLAY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_REPEAT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_REPEAT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_REPEAT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SECTIONOBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SECTIONOBJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SECTIONOBJECT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_WIPEOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_WIPEOUT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_WIPEOUT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_BOOLEAN_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_BOOLEAN_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_BOOLEAN_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_BOX_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_BOX_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_BOX_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_CONE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_CONE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_CONE_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_CYLINDER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_CYLINDER_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_CYLINDER_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_FILLET_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_FILLET_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_FILLET_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_HISTORY_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_HISTORY_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_HISTORY_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_SPHERE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_SPHERE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_SPHERE_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_TORUS_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_TORUS_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_TORUS_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_WEDGE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_WEDGE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_WEDGE_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCGEOMDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCGEOMDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCGEOMDEPENDENCY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCNETWORK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCNETWORK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCNETWORK(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKALIGNMENTGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKALIGNMENTGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKALIGNMENTGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKALIGNMENTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKALIGNMENTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKALIGNMENTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKBASEPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKBASEPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKBASEPOINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKFLIPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKFLIPACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKFLIPACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKFLIPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKFLIPGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKFLIPGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKFLIPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKFLIPPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKFLIPPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKGRIPLOCATIONCOMPONENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKGRIPLOCATIONCOMPONENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKGRIPLOCATIONCOMPONENT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLINEARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLINEARGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLINEARGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLOOKUPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLOOKUPGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLOOKUPGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKMOVEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKMOVEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKMOVEACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKROTATEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKROTATEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKROTATEACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKROTATIONGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKROTATIONGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKROTATIONGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKSCALEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKSCALEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKSCALEACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKVISIBILITYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKVISIBILITYGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKVISIBILITYGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_CELLSTYLEMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_CELLSTYLEMAP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_CELLSTYLEMAP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DETAILVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DETAILVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DETAILVIEWSTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DICTIONARYVAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DICTIONARYVAR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DICTIONARYVAR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DICTIONARYWDFLT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DICTIONARYWDFLT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DICTIONARYWDFLT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DYNAMICBLOCKPURGEPREVENTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DYNAMICBLOCKPURGEPREVENTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DYNAMICBLOCKPURGEPREVENTER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_FIELD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_FIELD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_FIELD(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_FIELDLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_FIELDLIST" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_FIELDLIST(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_GEODATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_GEODATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_GEODATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_GROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_GROUP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_GROUP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IDBUFFER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IDBUFFER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IDBUFFER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IMAGEDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IMAGEDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IMAGEDEF(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IMAGEDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IMAGEDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IMAGEDEF_REACTOR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_INDEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYERFILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYERFILTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYERFILTER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYER_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYER_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYER_INDEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYOUT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYOUT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PLACEHOLDER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PLACEHOLDER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PLACEHOLDER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PLOTSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PLOTSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PLOTSETTINGS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RASTERVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RASTERVARIABLES" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RASTERVARIABLES(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RENDERENVIRONMENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RENDERENVIRONMENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RENDERENVIRONMENT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SCALE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SCALE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SCALE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SECTIONVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SECTIONVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SECTIONVIEWSTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SECTION_MANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SECTION_MANAGER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SECTION_MANAGER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SORTENTSTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SORTENTSTABLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SORTENTSTABLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SPATIAL_FILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SPATIAL_FILTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SPATIAL_FILTER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SUN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SUN" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SUN(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TABLEGEOMETRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TABLEGEOMETRY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TABLEGEOMETRY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VBA_PROJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VBA_PROJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VBA_PROJECT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_VISUALSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_VISUALSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_VISUALSTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_WIPEOUTVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_WIPEOUTVARIABLES" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_WIPEOUTVARIABLES(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_XRECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_XRECORD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_XRECORD(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PDFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PDFDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PDFDEFINITION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DGNDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DGNDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DGNDEFINITION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DWFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DWFDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DWFDEFINITION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ARC_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ARC_DIMENSION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ARC_DIMENSION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_HELIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_HELIX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_HELIX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LARGE_RADIAL_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LARGE_RADIAL_DIMENSION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LARGE_RADIAL_DIMENSION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LAYOUTPRINTCONFIG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LAYOUTPRINTCONFIG" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LAYOUTPRINTCONFIG(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PLANESURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PLANESURFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PLANESURFACE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUD(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_BREP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_BREP_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_BREP_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_CHAMFER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_CHAMFER_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_CHAMFER_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ACSH_PYRAMID_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ACSH_PYRAMID_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ACSH_PYRAMID_CLASS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ALDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ALDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ALDIMOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOC2DCONSTRAINTGROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOC2DCONSTRAINTGROUP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOC2DCONSTRAINTGROUP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCARRAYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCARRAYACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCARRAYACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCASMBODYACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCASMBODYACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCASMBODYACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCBLENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCBLENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCBLENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCCOMPOUNDACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCCOMPOUNDACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCCOMPOUNDACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCDEPENDENCY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCDIMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCDIMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCDIMDEPENDENCYBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCEXTENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCEXTENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCEXTENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCEXTRUDEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCEXTRUDEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCEXTRUDEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCFACEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCFACEACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCFACEACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCFILLETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCFILLETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCFILLETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCLOFTEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCLOFTEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCLOFTEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCNETWORKSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCNETWORKSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCNETWORKSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCOBJECTACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCOBJECTACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCOBJECTACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCOFFSETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCOFFSETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCOFFSETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCOSNAPPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCOSNAPPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCOSNAPPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCPATCHSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCPATCHSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCPATCHSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCPATHACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCPATHACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCPATHACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCPLANESURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCPLANESURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCPLANESURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCREVOLVEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCREVOLVEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCREVOLVEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCTRIMSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCTRIMSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCTRIMSURFACEACTIONBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCVALUEDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCVALUEDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCVALUEDEPENDENCY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCVARIABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCVARIABLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCVARIABLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCVERTEXACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCVERTEXACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCVERTEXACTIONPARAM(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLKREFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLKREFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLKREFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKALIGNEDCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKALIGNEDCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKALIGNEDCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKANGULARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKANGULARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKANGULARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKARRAYACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKARRAYACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKARRAYACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKDIAMETRICCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKDIAMETRICCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKDIAMETRICCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKHORIZONTALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKHORIZONTALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKHORIZONTALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLINEARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLINEARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLINEARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLINEARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLINEARPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLINEARPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLOOKUPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLOOKUPACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLOOKUPACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKLOOKUPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKLOOKUPPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKLOOKUPPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKPARAMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKPARAMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKPARAMDEPENDENCYBODY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKPOINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKPOLARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKPOLARGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKPOLARGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKPOLARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKPOLARPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKPOLARPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKPOLARSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKPOLARSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKPOLARSTRETCHACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKRADIALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKRADIALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKRADIALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKREPRESENTATION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKREPRESENTATION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKREPRESENTATION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKROTATIONPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKROTATIONPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKROTATIONPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKSTRETCHACTION(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKUSERPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKUSERPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKUSERPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKVERTICALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKVERTICALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKVERTICALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKVISIBILITYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKVISIBILITYPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKVISIBILITYPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKXYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKXYGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKXYGRIP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_BLOCKXYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_BLOCKXYPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_BLOCKXYPARAMETER(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DATALINK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DATALINK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DATALINK(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_DBCOLOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_DBCOLOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_DBCOLOR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_EVALUATION_GRAPH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_EVALUATION_GRAPH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_EVALUATION_GRAPH(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_FCFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_FCFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_FCFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_GRADIENT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_GRADIENT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_GRADIENT_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_GROUND_PLANE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_GROUND_PLANE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_GROUND_PLANE_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IBL_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IBL_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IBL_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_IMAGE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_IMAGE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_IMAGE_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LEADEROBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LEADEROBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_LIGHTLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_LIGHTLIST" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_LIGHTLIST(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MATERIAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MATERIAL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MATERIAL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MENTALRAYRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MENTALRAYRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MENTALRAYRENDERSETTINGS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MLEADERSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MLEADERSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MLEADERSTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_MTEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_MTEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_MTEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_OBJECT_PTR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_OBJECT_PTR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_OBJECT_PTR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PARTIAL_VIEWING_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PARTIAL_VIEWING_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PARTIAL_VIEWING_INDEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDCOLORMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDCOLORMAP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDCOLORMAP(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDDEF(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDDEFEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDDEFEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDDEFEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDDEF_REACTOR(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_POINTCLOUDDEF_REACTOR_EX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_POINTCLOUDDEF_REACTOR_EX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_POINTCLOUDDEF_REACTOR_EX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_PROXY_OBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_PROXY_OBJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_PROXY_OBJECT(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RAPIDRTRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RAPIDRTRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RAPIDRTRENDERSETTINGS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RENDERENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RENDERENTRY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RENDERENTRY(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RENDERGLOBAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RENDERGLOBAL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RENDERGLOBAL(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_RENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_RENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_RENDERSETTINGS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SECTION_SETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SECTION_SETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SECTION_SETTINGS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SKYLIGHT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SKYLIGHT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SKYLIGHT_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SOLID_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SOLID_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SOLID_BACKGROUND(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_SPATIAL_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_SPATIAL_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_SPATIAL_INDEX(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TABLESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TABLESTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TABLESTYLE(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_TEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_TEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_TEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCARRAYMODIFYPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCARRAYMODIFYPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCARRAYMODIFYPARAMETERS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCARRAYPATHPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCARRAYPATHPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCARRAYPATHPARAMETERS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCARRAYPOLARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCARRAYPOLARPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCARRAYPOLARPARAMETERS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_setup_ASSOCARRAYRECTANGULARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_setup_ASSOCARRAYRECTANGULARPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_setup_ASSOCARRAYRECTANGULARPARAMETERS(arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_name_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (char *)(char *) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_type_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (char *)(char *) ((arg1)->type);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_size_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (unsigned short)(unsigned short) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_offset_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (unsigned short)(unsigned short) ((arg1)->offset);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_is_indirect_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_is_indirect_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (unsigned short)(unsigned short) ((arg1)->is_indirect);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_is_malloc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_is_malloc_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (unsigned short)(unsigned short) ((arg1)->is_malloc);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_is_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_is_string_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (unsigned short)(unsigned short) ((arg1)->is_string);
  resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dwg_DYNAPI_field_dxf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dwg_DYNAPI_field_dxf_get" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  result = (short)(short) ((arg1)->dxf);
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dwg_DYNAPI_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Dwg_DYNAPI_field", 0, 0, 0)) SWIG_fail;
  result = (struct dwg_field_name_type_offset *)calloc(1, sizeof(struct dwg_field_name_type_offset));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Dwg_DYNAPI_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  struct dwg_field_name_type_offset *arg1 = (struct dwg_field_name_type_offset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_field_name_type_offset, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dwg_DYNAPI_field" "', argument " "1"" of type '" "struct dwg_field_name_type_offset *""'"); 
  }
  arg1 = (struct dwg_field_name_type_offset *)(argp1);
  free((char *) arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dwg_DYNAPI_field_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_dwg_field_name_type_offset, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Dwg_DYNAPI_field_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_is_dwg_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_dwg_entity" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (bool)is_dwg_entity((char const *)arg1);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_dwg_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_dwg_object" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (bool)is_dwg_object((char const *)arg1);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_header_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  Dwg_DYNAPI_field *arg4 = (Dwg_DYNAPI_field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_header_value", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_header_value" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_header_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_header_value" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_header_value" "', argument " "4"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg4 = (Dwg_DYNAPI_field *)(argp4);
  result = (bool)dwg_dynapi_header_value((struct _dwg_struct const *)arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_entity_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = (void *) 0 ;
  Dwg_DYNAPI_field *arg5 = (Dwg_DYNAPI_field *) 0 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_entity_value", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_entity_value" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_entity_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_entity_value" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_entity_value" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_dynapi_entity_value" "', argument " "5"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg5 = (Dwg_DYNAPI_field *)(argp5);
  result = (bool)dwg_dynapi_entity_value(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  Dwg_DYNAPI_field *arg4 = (Dwg_DYNAPI_field *) 0 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_common_value", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_common_value" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_common_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_common_value" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_common_value" "', argument " "4"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg4 = (Dwg_DYNAPI_field *)(argp4);
  result = (bool)dwg_dynapi_common_value(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_subclass_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = (void *) 0 ;
  Dwg_DYNAPI_field *arg5 = (Dwg_DYNAPI_field *) 0 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_subclass_value", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_subclass_value" "', argument " "1"" of type '" "void const *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_subclass_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_subclass_value" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_subclass_value" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_dynapi_subclass_value" "', argument " "5"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg5 = (Dwg_DYNAPI_field *)(argp5);
  result = (bool)dwg_dynapi_subclass_value((void const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_header_utf8text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  char **arg3 = (char **) 0 ;
  int *arg4 = (int *) 0 ;
  Dwg_DYNAPI_field *arg5 = (Dwg_DYNAPI_field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_header_utf8text", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_header_utf8text" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_header_utf8text" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_header_utf8text" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = (char **)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_header_utf8text" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_dynapi_header_utf8text" "', argument " "5"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg5 = (Dwg_DYNAPI_field *)(argp5);
  result = (bool)dwg_dynapi_header_utf8text((struct _dwg_struct const *)arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_entity_utf8text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char **arg4 = (char **) 0 ;
  int *arg5 = (int *) 0 ;
  Dwg_DYNAPI_field *arg6 = (Dwg_DYNAPI_field *) 0 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_entity_utf8text", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "4"" of type '" "char **""'"); 
  }
  arg4 = (char **)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dwg_dynapi_entity_utf8text" "', argument " "6"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg6 = (Dwg_DYNAPI_field *)(argp6);
  result = (bool)dwg_dynapi_entity_utf8text(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_utf8text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  char **arg3 = (char **) 0 ;
  int *arg4 = (int *) 0 ;
  Dwg_DYNAPI_field *arg5 = (Dwg_DYNAPI_field *) 0 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_common_utf8text", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_common_utf8text" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_common_utf8text" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_common_utf8text" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = (char **)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_common_utf8text" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dwg_dynapi_common_utf8text" "', argument " "5"" of type '" "Dwg_DYNAPI_field *""'"); 
  }
  arg5 = (Dwg_DYNAPI_field *)(argp5);
  result = (bool)dwg_dynapi_common_utf8text(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_header_set_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_header_set_value", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_header_set_value" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_header_set_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_header_set_value" "', argument " "3"" of type '" "void const *""'"); 
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dwg_dynapi_header_set_value" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = (bool)(val4);
  result = (bool)dwg_dynapi_header_set_value(arg1,(char const *)arg2,(void const *)arg3,arg4);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_entity_set_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = (void *) 0 ;
  bool arg5 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_entity_set_value", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_entity_set_value" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_entity_set_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_entity_set_value" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dwg_dynapi_entity_set_value" "', argument " "4"" of type '" "void const *""'"); 
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dwg_dynapi_entity_set_value" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = (bool)(val5);
  result = (bool)dwg_dynapi_entity_set_value(arg1,(char const *)arg2,(char const *)arg3,(void const *)arg4,arg5);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_set_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  bool arg4 ;
  int res1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_common_set_value", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_common_set_value" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_common_set_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_common_set_value" "', argument " "3"" of type '" "void const *""'"); 
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dwg_dynapi_common_set_value" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = (bool)(val4);
  result = (bool)dwg_dynapi_common_set_value(arg1,(char const *)arg2,(void const *)arg3,arg4);
  resultobj = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_handle_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  Dwg_Object_Ref *arg2 = (Dwg_Object_Ref *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_handle_name", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_handle_name" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_handle_name" "', argument " "2"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg2 = (Dwg_Object_Ref *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dwg_dynapi_handle_name" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  result = (char *)dwg_dynapi_handle_name((struct _dwg_struct const *)arg1,arg2,arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_header_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_header_field" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_header_field((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_entity_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_entity_field", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_entity_field" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_entity_field" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_entity_field((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_subclass_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_subclass_field", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_subclass_field" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_dynapi_subclass_field" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_subclass_field((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_entity_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_common_entity_field" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_common_entity_field((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_object_field(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_common_object_field" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_common_object_field((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_entity_fields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_entity_fields" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_entity_fields((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_entity_fields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_common_entity_fields", 0, 0, 0)) SWIG_fail;
  result = (Dwg_DYNAPI_field *)dwg_dynapi_common_entity_fields();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_common_object_fields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_dynapi_common_object_fields", 0, 0, 0)) SWIG_fail;
  result = (Dwg_DYNAPI_field *)dwg_dynapi_common_object_fields();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_subclass_fields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_DYNAPI_field *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_subclass_fields" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (Dwg_DYNAPI_field *)dwg_dynapi_subclass_fields((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_field_name_type_offset, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_dynapi_fields_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_dynapi_fields_size" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  result = (int)dwg_dynapi_fields_size((char const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_tablectrl_get_entries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object_Ref **result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_object_tablectrl_get_entries", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_tablectrl_get_entries" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_object_tablectrl_get_entries" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object_Ref **)dwg_object_tablectrl_get_entries((struct _dwg_object const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ref, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_get_table_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_get_table_name", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_get_table_name" "', argument " "1"" of type '" "Dwg_Object_Ref const *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_get_table_name" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (char *)dwg_ref_get_table_name((struct _dwg_object_ref const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ent_get_layer_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_obj_ent *arg1 = (dwg_obj_ent *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ent_get_layer_name", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_obj_ent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ent_get_layer_name" "', argument " "1"" of type '" "dwg_obj_ent const *""'"); 
  }
  arg1 = (dwg_obj_ent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ent_get_layer_name" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (char *)dwg_ent_get_layer_name((dwg_obj_ent const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_layer_get_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_obj_layer *arg1 = (dwg_obj_layer *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_obj_layer_get_name", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_obj_layer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_layer_get_name" "', argument " "1"" of type '" "dwg_obj_layer const *""'"); 
  }
  arg1 = (dwg_obj_layer *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_obj_layer_get_name" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (char *)dwg_obj_layer_get_name((dwg_obj_layer const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_table_get_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_obj_table_get_name", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_table_get_name" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_obj_table_get_name" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (char *)dwg_obj_table_get_name((struct _dwg_object const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ent_to_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_obj_ent *arg1 = (dwg_obj_ent *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ent_to_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_obj_ent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ent_to_object" "', argument " "1"" of type '" "dwg_obj_ent const *""'"); 
  }
  arg1 = (dwg_obj_ent *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ent_to_object" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object *)dwg_ent_to_object((dwg_obj_ent const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_object_to_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_object" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_object_to_object" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object_Object *)dwg_object_to_object(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_obj_to_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Object *arg1 = (Dwg_Object_Object *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_obj_obj_to_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_obj_to_object" "', argument " "1"" of type '" "Dwg_Object_Object const *""'"); 
  }
  arg1 = (Dwg_Object_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_obj_obj_to_object" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object *)dwg_obj_obj_to_object((struct _dwg_object_object const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_entity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object_Entity *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_object_to_entity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_entity" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_object_to_entity" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object_Entity *)dwg_object_to_entity(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_entity, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_get_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_get_type" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_object_get_type((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_get_fixedtype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_get_fixedtype" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (int)dwg_object_get_fixedtype((struct _dwg_object const *)arg1);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_get_dxfname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_get_dxfname" "', argument " "1"" of type '" "Dwg_Object const *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (char *)dwg_object_get_dxfname((struct _dwg_object const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_get_absref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  BITCODE_BL result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_get_absref", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_get_absref" "', argument " "1"" of type '" "Dwg_Object_Ref const *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_get_absref" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (BITCODE_BL)dwg_ref_get_absref((struct _dwg_object_ref const *)arg1,arg2);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_ref_get_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_ref_get_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_ref_get_object" "', argument " "1"" of type '" "Dwg_Object_Ref const *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_ref_get_object" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (Dwg_Object *)dwg_ref_get_object((struct _dwg_object_ref const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_absref_get_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_absref_get_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_absref_get_object" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_absref_get_object" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  result = (Dwg_Object *)dwg_absref_get_object((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_num_classes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_num_classes" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (unsigned int)dwg_get_num_classes((struct _dwg_struct const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_class(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Class *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_get_class", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_class" "', argument " "1"" of type '" "Dwg_Data const *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_get_class" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  result = (Dwg_Class *)dwg_get_class((struct _dwg_struct const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_class, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_get_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  BITCODE_BL arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Dwg_Object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_get_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_get_object" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dwg_get_object" "', argument " "2"" of type '" "BITCODE_BL""'");
  } 
  arg2 = (BITCODE_BL)(val2);
  result = (Dwg_Object *)dwg_get_object(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_generic_to_object(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_obj_generic *arg1 = (dwg_obj_generic *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  dwg_object *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_obj_generic_to_object", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_obj_generic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_generic_to_object" "', argument " "1"" of type '" "dwg_obj_generic const *""'"); 
  }
  arg1 = (dwg_obj_generic *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_obj_generic_to_object" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (dwg_object *)dwg_obj_generic_to_object((dwg_obj_generic const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_object, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_obj_generic_parent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dwg_obj_generic *arg1 = (dwg_obj_generic *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  dwg_obj_obj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dwg_obj_generic_parent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dwg_obj_generic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_obj_generic_parent" "', argument " "1"" of type '" "dwg_obj_generic const *""'"); 
  }
  arg1 = (dwg_obj_generic *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dwg_obj_generic_parent" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  result = (dwg_obj_obj *)dwg_obj_generic_parent((dwg_obj_generic const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_obj_obj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  struct dwg_entity_DIMENSION_common *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (struct dwg_entity_DIMENSION_common *)dwg_object_to_DIMENSION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dwg_entity_DIMENSION_common, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall__3DFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DFACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall__3DFACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity__3DFACE **)dwg_getall__3DFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_3DFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall__3DLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DLINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall__3DLINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity__3DLINE **)dwg_getall__3DLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_3DLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall__3DSOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DSOLID **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall__3DSOLID" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity__3DSOLID **)dwg_getall__3DSOLID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ARC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ARC" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ARC **)dwg_getall_ARC(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ARC, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ATTDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTDEF **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ATTDEF" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ATTDEF **)dwg_getall_ATTDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ATTDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ATTRIB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTRIB **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ATTRIB" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ATTRIB **)dwg_getall_ATTRIB(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ATTRIB, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BLOCK **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCK" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_BLOCK **)dwg_getall_BLOCK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_BLOCK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BODY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_BODY **)dwg_getall_BODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_CAMERA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CAMERA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_CAMERA" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_CAMERA **)dwg_getall_CAMERA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_CAMERA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_CIRCLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CIRCLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_CIRCLE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_CIRCLE **)dwg_getall_CIRCLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_CIRCLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DGNUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DGNUNDERLAY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DGNUNDERLAY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DGNUNDERLAY **)dwg_getall_DGNUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_ALIGNED(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ALIGNED **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_ALIGNED" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_ALIGNED **)dwg_getall_DIMENSION_ALIGNED(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_ANG2LN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG2LN **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_ANG2LN" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG2LN **)dwg_getall_DIMENSION_ANG2LN(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_ANG3PT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG3PT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_ANG3PT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG3PT **)dwg_getall_DIMENSION_ANG3PT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_DIAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_DIAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_DIAMETER" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_DIAMETER **)dwg_getall_DIMENSION_DIAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_LINEAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_LINEAR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_LINEAR" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_LINEAR **)dwg_getall_DIMENSION_LINEAR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_ORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ORDINATE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_ORDINATE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_ORDINATE **)dwg_getall_DIMENSION_ORDINATE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMENSION_RADIUS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_RADIUS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMENSION_RADIUS" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DIMENSION_RADIUS **)dwg_getall_DIMENSION_RADIUS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DWFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DWFUNDERLAY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DWFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_DWFUNDERLAY **)dwg_getall_DWFUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ELLIPSE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ELLIPSE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ELLIPSE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ELLIPSE **)dwg_getall_ELLIPSE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ELLIPSE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ENDBLK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDBLK **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ENDBLK" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ENDBLK **)dwg_getall_ENDBLK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ENDBLK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ENDREP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDREP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ENDREP" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ENDREP **)dwg_getall_ENDREP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ENDREP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_HATCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HATCH **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_HATCH" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_HATCH **)dwg_getall_HATCH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_IMAGE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IMAGE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_IMAGE **)dwg_getall_IMAGE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_IMAGE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_INSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_INSERT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_INSERT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_INSERT **)dwg_getall_INSERT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_INSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_JUMP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_JUMP" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_JUMP **)dwg_getall_JUMP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_JUMP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LEADER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LEADER" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LEADER **)dwg_getall_LEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LIGHT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LIGHT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LIGHT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LIGHT **)dwg_getall_LIGHT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LIGHT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LINE **)dwg_getall_LINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LOAD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LOAD **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LOAD" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LOAD **)dwg_getall_LOAD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LOAD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LWPOLYLINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LWPOLYLINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LWPOLYLINE **)dwg_getall_LWPOLYLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MESH **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MESH" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_MESH **)dwg_getall_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MINSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MINSERT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MINSERT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_MINSERT **)dwg_getall_MINSERT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_MINSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MLINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MLINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_MLINE **)dwg_getall_MLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_MLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MTEXT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MTEXT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_MTEXT **)dwg_getall_MTEXT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_MTEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MULTILEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MULTILEADER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MULTILEADER" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_MULTILEADER **)dwg_getall_MULTILEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_OLE2FRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLE2FRAME **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_OLE2FRAME" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_OLE2FRAME **)dwg_getall_OLE2FRAME(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_OLE2FRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_OLEFRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLEFRAME **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_OLEFRAME" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_OLEFRAME **)dwg_getall_OLEFRAME(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_OLEFRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PDFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PDFUNDERLAY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PDFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_PDFUNDERLAY **)dwg_getall_PDFUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POINT **)dwg_getall_POINT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POINT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POLYLINE_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_2D **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POLYLINE_2D" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POLYLINE_2D **)dwg_getall_POLYLINE_2D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POLYLINE_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_3D **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POLYLINE_3D" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POLYLINE_3D **)dwg_getall_POLYLINE_3D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POLYLINE_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_MESH **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POLYLINE_MESH" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POLYLINE_MESH **)dwg_getall_POLYLINE_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POLYLINE_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_PFACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POLYLINE_PFACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POLYLINE_PFACE **)dwg_getall_POLYLINE_PFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PROXY_ENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PROXY_ENTITY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PROXY_ENTITY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_PROXY_ENTITY **)dwg_getall_PROXY_ENTITY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_RAY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RAY" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_RAY **)dwg_getall_RAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_REGION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REGION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_REGION" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_REGION **)dwg_getall_REGION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_REPEAT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REPEAT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_REPEAT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_REPEAT **)dwg_getall_REPEAT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_REPEAT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SECTIONOBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SECTIONOBJECT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SECTIONOBJECT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_SECTIONOBJECT **)dwg_getall_SECTIONOBJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SEQEND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SEQEND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SEQEND" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_SEQEND **)dwg_getall_SEQEND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_SEQEND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SHAPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SHAPE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SHAPE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_SHAPE **)dwg_getall_SHAPE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_SHAPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SOLID **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SOLID" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_SOLID **)dwg_getall_SOLID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_SOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SPLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SPLINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SPLINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_SPLINE **)dwg_getall_SPLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_SPLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TEXT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TEXT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_TEXT **)dwg_getall_TEXT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_TEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TOLERANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TOLERANCE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TOLERANCE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_TOLERANCE **)dwg_getall_TOLERANCE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_TOLERANCE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TRACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TRACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TRACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_TRACE **)dwg_getall_TRACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_TRACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_UNKNOWN_ENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_UNKNOWN_ENT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_UNKNOWN_ENT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_UNKNOWN_ENT **)dwg_getall_UNKNOWN_ENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_UNKNOWN_ENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VERTEX_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_2D **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VERTEX_2D" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VERTEX_2D **)dwg_getall_VERTEX_2D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VERTEX_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VERTEX_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_3D **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VERTEX_3D" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VERTEX_3D **)dwg_getall_VERTEX_3D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VERTEX_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_MESH **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VERTEX_MESH" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VERTEX_MESH **)dwg_getall_VERTEX_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VERTEX_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VERTEX_PFACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE **)dwg_getall_VERTEX_PFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VERTEX_PFACE_FACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE_FACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VERTEX_PFACE_FACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE_FACE **)dwg_getall_VERTEX_PFACE_FACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VIEWPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VIEWPORT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VIEWPORT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_VIEWPORT **)dwg_getall_VIEWPORT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_VIEWPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_WIPEOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_WIPEOUT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_WIPEOUT" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_WIPEOUT **)dwg_getall_WIPEOUT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_WIPEOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_XLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_XLINE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_XLINE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_XLINE **)dwg_getall_XLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ARC_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC_DIMENSION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ARC_DIMENSION" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_ARC_DIMENSION **)dwg_getall_ARC_DIMENSION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_HELIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HELIX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_HELIX" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_HELIX **)dwg_getall_HELIX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_HELIX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LARGE_RADIAL_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LARGE_RADIAL_DIMENSION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LARGE_RADIAL_DIMENSION" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LARGE_RADIAL_DIMENSION **)dwg_getall_LARGE_RADIAL_DIMENSION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYOUTPRINTCONFIG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LAYOUTPRINTCONFIG **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYOUTPRINTCONFIG" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_LAYOUTPRINTCONFIG **)dwg_getall_LAYOUTPRINTCONFIG(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PLANESURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PLANESURFACE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PLANESURFACE" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_PLANESURFACE **)dwg_getall_PLANESURFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_PLANESURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUD **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUD" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POINTCLOUD **)dwg_getall_POINTCLOUD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POINTCLOUD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object_Ref *arg1 = (Dwg_Object_Ref *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUDEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object_ref, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDEX" "', argument " "1"" of type '" "Dwg_Object_Ref *""'"); 
  }
  arg1 = (Dwg_Object_Ref *)(argp1);
  result = (Dwg_Entity_POINTCLOUDEX **)dwg_getall_POINTCLOUDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_BOOLEAN_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOOLEAN_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_BOOLEAN_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_BOOLEAN_CLASS **)dwg_getall_ACSH_BOOLEAN_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_BOX_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOX_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_BOX_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_BOX_CLASS **)dwg_getall_ACSH_BOX_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_CONE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CONE_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_CONE_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_CONE_CLASS **)dwg_getall_ACSH_CONE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_CYLINDER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CYLINDER_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_CYLINDER_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_CYLINDER_CLASS **)dwg_getall_ACSH_CYLINDER_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_FILLET_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_FILLET_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_FILLET_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_FILLET_CLASS **)dwg_getall_ACSH_FILLET_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_HISTORY_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_HISTORY_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_HISTORY_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_HISTORY_CLASS **)dwg_getall_ACSH_HISTORY_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_SPHERE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_SPHERE_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_SPHERE_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_SPHERE_CLASS **)dwg_getall_ACSH_SPHERE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_TORUS_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_TORUS_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_TORUS_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_TORUS_CLASS **)dwg_getall_ACSH_TORUS_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_WEDGE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_WEDGE_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_WEDGE_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_WEDGE_CLASS **)dwg_getall_ACSH_WEDGE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_APPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_APPID" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_APPID **)dwg_getall_APPID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_APPID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_APPID_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_APPID_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_APPID_CONTROL **)dwg_getall_APPID_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_APPID_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCGEOMDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCGEOMDEPENDENCY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCGEOMDEPENDENCY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCGEOMDEPENDENCY **)dwg_getall_ASSOCGEOMDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCNETWORK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORK **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCNETWORK" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCNETWORK **)dwg_getall_ASSOCNETWORK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKALIGNMENTGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKALIGNMENTGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTGRIP **)dwg_getall_BLOCKALIGNMENTGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKALIGNMENTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKALIGNMENTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTPARAMETER **)dwg_getall_BLOCKALIGNMENTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKBASEPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKBASEPOINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKBASEPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKBASEPOINTPARAMETER **)dwg_getall_BLOCKBASEPOINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKFLIPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKFLIPACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKFLIPACTION **)dwg_getall_BLOCKFLIPACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKFLIPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKFLIPGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKFLIPGRIP **)dwg_getall_BLOCKFLIPGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKFLIPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKFLIPPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKFLIPPARAMETER **)dwg_getall_BLOCKFLIPPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKGRIPLOCATIONCOMPONENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKGRIPLOCATIONCOMPONENT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT **)dwg_getall_BLOCKGRIPLOCATIONCOMPONENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLINEARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLINEARGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLINEARGRIP **)dwg_getall_BLOCKLINEARGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLOOKUPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLOOKUPGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPGRIP **)dwg_getall_BLOCKLOOKUPGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKMOVEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKMOVEACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKMOVEACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKMOVEACTION **)dwg_getall_BLOCKMOVEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKROTATEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATEACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKROTATEACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKROTATEACTION **)dwg_getall_BLOCKROTATEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKROTATIONGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKROTATIONGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONGRIP **)dwg_getall_BLOCKROTATIONGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKSCALEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSCALEACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKSCALEACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKSCALEACTION **)dwg_getall_BLOCKSCALEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKVISIBILITYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKVISIBILITYGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYGRIP **)dwg_getall_BLOCKVISIBILITYGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCK_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCK_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCK_CONTROL **)dwg_getall_BLOCK_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCK_HEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_HEADER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCK_HEADER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCK_HEADER **)dwg_getall_BLOCK_HEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_CELLSTYLEMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CELLSTYLEMAP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_CELLSTYLEMAP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_CELLSTYLEMAP **)dwg_getall_CELLSTYLEMAP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DETAILVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DETAILVIEWSTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DETAILVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DETAILVIEWSTYLE **)dwg_getall_DETAILVIEWSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DICTIONARY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DICTIONARY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DICTIONARY **)dwg_getall_DICTIONARY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DICTIONARY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DICTIONARYVAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYVAR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DICTIONARYVAR" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DICTIONARYVAR **)dwg_getall_DICTIONARYVAR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DICTIONARYWDFLT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYWDFLT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DICTIONARYWDFLT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DICTIONARYWDFLT **)dwg_getall_DICTIONARYWDFLT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMSTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DIMSTYLE **)dwg_getall_DIMSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DIMSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DIMSTYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DIMSTYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DIMSTYLE_CONTROL **)dwg_getall_DIMSTYLE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DUMMY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DUMMY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DUMMY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DUMMY **)dwg_getall_DUMMY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DUMMY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DYNAMICBLOCKPURGEPREVENTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DYNAMICBLOCKPURGEPREVENTER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DYNAMICBLOCKPURGEPREVENTER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DYNAMICBLOCKPURGEPREVENTER **)dwg_getall_DYNAMICBLOCKPURGEPREVENTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_FIELD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELD **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_FIELD" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_FIELD **)dwg_getall_FIELD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_FIELD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_FIELDLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELDLIST **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_FIELDLIST" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_FIELDLIST **)dwg_getall_FIELDLIST(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_FIELDLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_GEODATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GEODATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_GEODATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_GEODATA **)dwg_getall_GEODATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_GEODATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_GROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_GROUP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_GROUP **)dwg_getall_GROUP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_GROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IDBUFFER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IDBUFFER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IDBUFFER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_IDBUFFER **)dwg_getall_IDBUFFER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_IDBUFFER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IMAGEDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IMAGEDEF" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_IMAGEDEF **)dwg_getall_IMAGEDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_IMAGEDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IMAGEDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF_REACTOR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IMAGEDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_IMAGEDEF_REACTOR **)dwg_getall_IMAGEDEF_REACTOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_INDEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_INDEX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_INDEX **)dwg_getall_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYER **)dwg_getall_LAYER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYERFILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYERFILTER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYERFILTER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYERFILTER **)dwg_getall_LAYERFILTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYERFILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYER_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYER_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYER_CONTROL **)dwg_getall_LAYER_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYER_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_INDEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYER_INDEX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYER_INDEX **)dwg_getall_LAYER_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYER_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LAYOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYOUT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LAYOUT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LAYOUT **)dwg_getall_LAYOUT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LAYOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LONG_TRANSACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LONG_TRANSACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LONG_TRANSACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LONG_TRANSACTION **)dwg_getall_LONG_TRANSACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LONG_TRANSACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LTYPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LTYPE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LTYPE **)dwg_getall_LTYPE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LTYPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LTYPE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LTYPE_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LTYPE_CONTROL **)dwg_getall_LTYPE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MLINESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLINESTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MLINESTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_MLINESTYLE **)dwg_getall_MLINESTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_MLINESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PLACEHOLDER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLACEHOLDER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PLACEHOLDER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_PLACEHOLDER **)dwg_getall_PLACEHOLDER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_PLACEHOLDER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PLOTSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLOTSETTINGS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PLOTSETTINGS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_PLOTSETTINGS **)dwg_getall_PLOTSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RASTERVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RASTERVARIABLES **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RASTERVARIABLES" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RASTERVARIABLES **)dwg_getall_RASTERVARIABLES(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RENDERENVIRONMENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENVIRONMENT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RENDERENVIRONMENT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RENDERENVIRONMENT **)dwg_getall_RENDERENVIRONMENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SCALE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SCALE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SCALE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SCALE **)dwg_getall_SCALE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SCALE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SECTIONVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTIONVIEWSTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SECTIONVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SECTIONVIEWSTYLE **)dwg_getall_SECTIONVIEWSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SECTION_MANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_MANAGER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SECTION_MANAGER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SECTION_MANAGER **)dwg_getall_SECTION_MANAGER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SORTENTSTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SORTENTSTABLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SORTENTSTABLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SORTENTSTABLE **)dwg_getall_SORTENTSTABLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SPATIAL_FILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_FILTER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SPATIAL_FILTER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SPATIAL_FILTER **)dwg_getall_SPATIAL_FILTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_STYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_STYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_STYLE **)dwg_getall_STYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_STYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_STYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_STYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_STYLE_CONTROL **)dwg_getall_STYLE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SUN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SUN **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SUN" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SUN **)dwg_getall_SUN(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SUN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TABLEGEOMETRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLEGEOMETRY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TABLEGEOMETRY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_TABLEGEOMETRY **)dwg_getall_TABLEGEOMETRY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_UCS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_UCS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_UCS **)dwg_getall_UCS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_UCS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_UCS_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_UCS_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_UCS_CONTROL **)dwg_getall_UCS_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_UCS_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_UNKNOWN_OBJ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UNKNOWN_OBJ **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_UNKNOWN_OBJ" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_UNKNOWN_OBJ **)dwg_getall_UNKNOWN_OBJ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_UNKNOWN_OBJ, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VBA_PROJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VBA_PROJECT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VBA_PROJECT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VBA_PROJECT **)dwg_getall_VBA_PROJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VBA_PROJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VIEW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VIEW" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VIEW **)dwg_getall_VIEW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VIEW, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VIEW_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VIEW_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VIEW_CONTROL **)dwg_getall_VIEW_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VISUALSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VISUALSTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VISUALSTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VISUALSTYLE **)dwg_getall_VISUALSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VISUALSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VPORT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VPORT **)dwg_getall_VPORT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VPORT_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VPORT_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VPORT_CONTROL **)dwg_getall_VPORT_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VX_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_CONTROL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VX_CONTROL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VX_CONTROL **)dwg_getall_VX_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VX_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_VX_TABLE_RECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_TABLE_RECORD **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_VX_TABLE_RECORD" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_VX_TABLE_RECORD **)dwg_getall_VX_TABLE_RECORD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_WIPEOUTVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_WIPEOUTVARIABLES **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_WIPEOUTVARIABLES" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_WIPEOUTVARIABLES **)dwg_getall_WIPEOUTVARIABLES(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_XRECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_XRECORD **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_XRECORD" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_XRECORD **)dwg_getall_XRECORD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_XRECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PDFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PDFDEFINITION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PDFDEFINITION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_PDFDEFINITION **)dwg_getall_PDFDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DGNDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DGNDEFINITION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DGNDEFINITION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DGNDEFINITION **)dwg_getall_DGNDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DWFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DWFDEFINITION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DWFDEFINITION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DWFDEFINITION **)dwg_getall_DWFDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_BREP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BREP_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_BREP_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_BREP_CLASS **)dwg_getall_ACSH_BREP_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_CHAMFER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CHAMFER_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_CHAMFER_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_CHAMFER_CLASS **)dwg_getall_ACSH_CHAMFER_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ACSH_PYRAMID_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_PYRAMID_CLASS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ACSH_PYRAMID_CLASS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ACSH_PYRAMID_CLASS **)dwg_getall_ACSH_PYRAMID_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ALDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ALDIMOBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ALDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ALDIMOBJECTCONTEXTDATA **)dwg_getall_ALDIMOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOC2DCONSTRAINTGROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOC2DCONSTRAINTGROUP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOC2DCONSTRAINTGROUP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOC2DCONSTRAINTGROUP **)dwg_getall_ASSOC2DCONSTRAINTGROUP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCACTION **)dwg_getall_ASSOCACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCACTIONPARAM **)dwg_getall_ASSOCACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCARRAYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCARRAYACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCARRAYACTIONBODY **)dwg_getall_ASSOCARRAYACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCASMBODYACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCASMBODYACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCASMBODYACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCASMBODYACTIONPARAM **)dwg_getall_ASSOCASMBODYACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCBLENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCBLENDSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCBLENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCBLENDSURFACEACTIONBODY **)dwg_getall_ASSOCBLENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCCOMPOUNDACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCCOMPOUNDACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCCOMPOUNDACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCCOMPOUNDACTIONPARAM **)dwg_getall_ASSOCCOMPOUNDACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDEPENDENCY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCDEPENDENCY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCDEPENDENCY **)dwg_getall_ASSOCDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCDIMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDIMDEPENDENCYBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCDIMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCDIMDEPENDENCYBODY **)dwg_getall_ASSOCDIMDEPENDENCYBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCEXTENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCEXTENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY **)dwg_getall_ASSOCEXTENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCEXTRUDEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCEXTRUDEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY **)dwg_getall_ASSOCEXTRUDEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCFACEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFACEACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCFACEACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCFACEACTIONPARAM **)dwg_getall_ASSOCFACEACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCFILLETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFILLETSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCFILLETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCFILLETSURFACEACTIONBODY **)dwg_getall_ASSOCFILLETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCLOFTEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCLOFTEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY **)dwg_getall_ASSOCLOFTEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCNETWORKSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCNETWORKSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY **)dwg_getall_ASSOCNETWORKSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCOBJECTACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOBJECTACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCOBJECTACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCOBJECTACTIONPARAM **)dwg_getall_ASSOCOBJECTACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCOFFSETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCOFFSETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY **)dwg_getall_ASSOCOFFSETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCOSNAPPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCOSNAPPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM **)dwg_getall_ASSOCOSNAPPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCPATCHSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATCHSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCPATCHSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCPATCHSURFACEACTIONBODY **)dwg_getall_ASSOCPATCHSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCPATHACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATHACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCPATHACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCPATHACTIONPARAM **)dwg_getall_ASSOCPATHACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCPLANESURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPLANESURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCPLANESURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCPLANESURFACEACTIONBODY **)dwg_getall_ASSOCPLANESURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPOINTREFACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCPOINTREFACTIONPARAM **)dwg_getall_ASSOCPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCREVOLVEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCREVOLVEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY **)dwg_getall_ASSOCREVOLVEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCTRIMSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCTRIMSURFACEACTIONBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCTRIMSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCTRIMSURFACEACTIONBODY **)dwg_getall_ASSOCTRIMSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCVALUEDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVALUEDEPENDENCY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCVALUEDEPENDENCY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCVALUEDEPENDENCY **)dwg_getall_ASSOCVALUEDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCVARIABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVARIABLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCVARIABLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCVARIABLE **)dwg_getall_ASSOCVARIABLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCVERTEXACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVERTEXACTIONPARAM **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCVERTEXACTIONPARAM" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCVERTEXACTIONPARAM **)dwg_getall_ASSOCVERTEXACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLKREFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLKREFOBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLKREFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLKREFOBJECTCONTEXTDATA **)dwg_getall_BLKREFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKALIGNEDCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKALIGNEDCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER **)dwg_getall_BLOCKALIGNEDCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKANGULARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKANGULARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER **)dwg_getall_BLOCKANGULARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKARRAYACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKARRAYACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKARRAYACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKARRAYACTION **)dwg_getall_BLOCKARRAYACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKDIAMETRICCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKDIAMETRICCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER **)dwg_getall_BLOCKDIAMETRICCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKHORIZONTALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKHORIZONTALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER **)dwg_getall_BLOCKHORIZONTALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLINEARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLINEARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER **)dwg_getall_BLOCKLINEARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLINEARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLINEARPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLINEARPARAMETER **)dwg_getall_BLOCKLINEARPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLOOKUPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLOOKUPACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPACTION **)dwg_getall_BLOCKLOOKUPACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKLOOKUPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKLOOKUPPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPPARAMETER **)dwg_getall_BLOCKLOOKUPPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKPARAMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPARAMDEPENDENCYBODY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKPARAMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKPARAMDEPENDENCYBODY **)dwg_getall_BLOCKPARAMDEPENDENCYBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKPOINTPARAMETER **)dwg_getall_BLOCKPOINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKPOLARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKPOLARGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKPOLARGRIP **)dwg_getall_BLOCKPOLARGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKPOLARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKPOLARPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKPOLARPARAMETER **)dwg_getall_BLOCKPOLARPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKPOLARSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARSTRETCHACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKPOLARSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKPOLARSTRETCHACTION **)dwg_getall_BLOCKPOLARSTRETCHACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKRADIALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKRADIALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER **)dwg_getall_BLOCKRADIALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKREPRESENTATION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKREPRESENTATION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKREPRESENTATION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKREPRESENTATION **)dwg_getall_BLOCKREPRESENTATION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKROTATIONPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKROTATIONPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONPARAMETER **)dwg_getall_BLOCKROTATIONPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSTRETCHACTION **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKSTRETCHACTION **)dwg_getall_BLOCKSTRETCHACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKUSERPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKUSERPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKUSERPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKUSERPARAMETER **)dwg_getall_BLOCKUSERPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKVERTICALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKVERTICALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER **)dwg_getall_BLOCKVERTICALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKVISIBILITYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKVISIBILITYPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYPARAMETER **)dwg_getall_BLOCKVISIBILITYPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKXYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYGRIP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKXYGRIP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKXYGRIP **)dwg_getall_BLOCKXYGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_BLOCKXYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYPARAMETER **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_BLOCKXYPARAMETER" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_BLOCKXYPARAMETER **)dwg_getall_BLOCKXYPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DATALINK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DATALINK **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DATALINK" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DATALINK **)dwg_getall_DATALINK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DATALINK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_DBCOLOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DBCOLOR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_DBCOLOR" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_DBCOLOR **)dwg_getall_DBCOLOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_DBCOLOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_EVALUATION_GRAPH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_EVALUATION_GRAPH **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_EVALUATION_GRAPH" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_EVALUATION_GRAPH **)dwg_getall_EVALUATION_GRAPH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_FCFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FCFOBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_FCFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_FCFOBJECTCONTEXTDATA **)dwg_getall_FCFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_GRADIENT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GRADIENT_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_GRADIENT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_GRADIENT_BACKGROUND **)dwg_getall_GRADIENT_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_GROUND_PLANE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUND_PLANE_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_GROUND_PLANE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_GROUND_PLANE_BACKGROUND **)dwg_getall_GROUND_PLANE_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IBL_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IBL_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IBL_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_IBL_BACKGROUND **)dwg_getall_IBL_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_IMAGE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGE_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_IMAGE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_IMAGE_BACKGROUND **)dwg_getall_IMAGE_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LEADEROBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LEADEROBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LEADEROBJECTCONTEXTDATA **)dwg_getall_LEADEROBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_LIGHTLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LIGHTLIST **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_LIGHTLIST" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_LIGHTLIST **)dwg_getall_LIGHTLIST(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_LIGHTLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MATERIAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MATERIAL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MATERIAL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_MATERIAL **)dwg_getall_MATERIAL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_MATERIAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MENTALRAYRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MENTALRAYRENDERSETTINGS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MENTALRAYRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_MENTALRAYRENDERSETTINGS **)dwg_getall_MENTALRAYRENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MLEADERSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLEADERSTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MLEADERSTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_MLEADERSTYLE **)dwg_getall_MLEADERSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_MTEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MTEXTOBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_MTEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_MTEXTOBJECTCONTEXTDATA **)dwg_getall_MTEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_OBJECT_PTR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_OBJECT_PTR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_OBJECT_PTR" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_OBJECT_PTR **)dwg_getall_OBJECT_PTR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_OBJECT_PTR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PARTIAL_VIEWING_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PARTIAL_VIEWING_INDEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PARTIAL_VIEWING_INDEX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_PARTIAL_VIEWING_INDEX **)dwg_getall_PARTIAL_VIEWING_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDCOLORMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDCOLORMAP **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDCOLORMAP" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_POINTCLOUDCOLORMAP **)dwg_getall_POINTCLOUDCOLORMAP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDDEF" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF **)dwg_getall_POINTCLOUDDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDDEFEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEFEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDDEFEX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEFEX **)dwg_getall_POINTCLOUDDEFEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR **)dwg_getall_POINTCLOUDDEF_REACTOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_POINTCLOUDDEF_REACTOR_EX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR_EX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_POINTCLOUDDEF_REACTOR_EX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR_EX **)dwg_getall_POINTCLOUDDEF_REACTOR_EX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_PROXY_OBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PROXY_OBJECT **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_PROXY_OBJECT" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_PROXY_OBJECT **)dwg_getall_PROXY_OBJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RAPIDRTRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RAPIDRTRENDERSETTINGS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RAPIDRTRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RAPIDRTRENDERSETTINGS **)dwg_getall_RAPIDRTRENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RENDERENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENTRY **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RENDERENTRY" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RENDERENTRY **)dwg_getall_RENDERENTRY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RENDERENTRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RENDERGLOBAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERGLOBAL **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RENDERGLOBAL" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RENDERGLOBAL **)dwg_getall_RENDERGLOBAL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_RENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERSETTINGS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_RENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_RENDERSETTINGS **)dwg_getall_RENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SECTION_SETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_SETTINGS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SECTION_SETTINGS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SECTION_SETTINGS **)dwg_getall_SECTION_SETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SKYLIGHT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SKYLIGHT_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SKYLIGHT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SKYLIGHT_BACKGROUND **)dwg_getall_SKYLIGHT_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SOLID_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SOLID_BACKGROUND **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SOLID_BACKGROUND" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SOLID_BACKGROUND **)dwg_getall_SOLID_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_SPATIAL_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_INDEX **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_SPATIAL_INDEX" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_SPATIAL_INDEX **)dwg_getall_SPATIAL_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TABLESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLESTYLE **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TABLESTYLE" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_TABLESTYLE **)dwg_getall_TABLESTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_TABLESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_TEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TEXTOBJECTCONTEXTDATA **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_TEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_TEXTOBJECTCONTEXTDATA **)dwg_getall_TEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCARRAYMODIFYPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYMODIFYPARAMETERS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCARRAYMODIFYPARAMETERS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCARRAYMODIFYPARAMETERS **)dwg_getall_ASSOCARRAYMODIFYPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCARRAYPATHPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPATHPARAMETERS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCARRAYPATHPARAMETERS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPATHPARAMETERS **)dwg_getall_ASSOCARRAYPATHPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCARRAYPOLARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPOLARPARAMETERS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCARRAYPOLARPARAMETERS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPOLARPARAMETERS **)dwg_getall_ASSOCARRAYPOLARPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_getall_ASSOCARRAYRECTANGULARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Data *arg1 = (Dwg_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_struct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_getall_ASSOCARRAYRECTANGULARPARAMETERS" "', argument " "1"" of type '" "Dwg_Data *""'"); 
  }
  arg1 = (Dwg_Data *)(argp1);
  result = (Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS **)dwg_getall_ASSOCARRAYRECTANGULARPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to__3DFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to__3DFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity__3DFACE *)dwg_object_to__3DFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to__3DLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to__3DLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity__3DLINE *)dwg_object_to__3DLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to__3DSOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity__3DSOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to__3DSOLID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity__3DSOLID *)dwg_object_to__3DSOLID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ARC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ARC" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ARC *)dwg_object_to_ARC(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ATTDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ATTDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ATTDEF *)dwg_object_to_ATTDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ATTRIB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ATTRIB *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ATTRIB" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ATTRIB *)dwg_object_to_ATTRIB(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ATTRIB, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BLOCK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_BLOCK *)dwg_object_to_BLOCK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_BLOCK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_BODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_BODY *)dwg_object_to_BODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_CAMERA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CAMERA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_CAMERA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_CAMERA *)dwg_object_to_CAMERA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CAMERA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_CIRCLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_CIRCLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_CIRCLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_CIRCLE *)dwg_object_to_CIRCLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_CIRCLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DGNUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DGNUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DGNUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DGNUNDERLAY *)dwg_object_to_DGNUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_ALIGNED(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ALIGNED *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_ALIGNED" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_ALIGNED *)dwg_object_to_DIMENSION_ALIGNED(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ALIGNED, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_ANG2LN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG2LN *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_ANG2LN" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG2LN *)dwg_object_to_DIMENSION_ANG2LN(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG2LN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_ANG3PT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ANG3PT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_ANG3PT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_ANG3PT *)dwg_object_to_DIMENSION_ANG3PT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ANG3PT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_DIAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_DIAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_DIAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_DIAMETER *)dwg_object_to_DIMENSION_DIAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_DIAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_LINEAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_LINEAR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_LINEAR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_LINEAR *)dwg_object_to_DIMENSION_LINEAR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_LINEAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_ORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_ORDINATE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_ORDINATE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_ORDINATE *)dwg_object_to_DIMENSION_ORDINATE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_ORDINATE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMENSION_RADIUS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DIMENSION_RADIUS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMENSION_RADIUS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DIMENSION_RADIUS *)dwg_object_to_DIMENSION_RADIUS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_DIMENSION_RADIUS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DWFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_DWFUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DWFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_DWFUNDERLAY *)dwg_object_to_DWFUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ELLIPSE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ELLIPSE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ELLIPSE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ELLIPSE *)dwg_object_to_ELLIPSE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ELLIPSE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ENDBLK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDBLK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ENDBLK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ENDBLK *)dwg_object_to_ENDBLK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDBLK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ENDREP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ENDREP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ENDREP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ENDREP *)dwg_object_to_ENDREP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ENDREP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_HATCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HATCH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_HATCH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_HATCH *)dwg_object_to_HATCH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HATCH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IMAGE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_IMAGE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IMAGE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_IMAGE *)dwg_object_to_IMAGE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_IMAGE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_INSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_INSERT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_INSERT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_INSERT *)dwg_object_to_INSERT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_INSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_JUMP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_JUMP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_JUMP *)dwg_object_to_JUMP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_JUMP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LEADER *)dwg_object_to_LEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LIGHT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LIGHT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LIGHT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LIGHT *)dwg_object_to_LIGHT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LIGHT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LINE *)dwg_object_to_LINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LOAD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LOAD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LOAD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LOAD *)dwg_object_to_LOAD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LOAD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LWPOLYLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LWPOLYLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LWPOLYLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LWPOLYLINE *)dwg_object_to_LWPOLYLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LWPOLYLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_MESH *)dwg_object_to_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MINSERT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MINSERT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MINSERT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_MINSERT *)dwg_object_to_MINSERT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MINSERT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_MLINE *)dwg_object_to_MLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MTEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MTEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MTEXT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_MTEXT *)dwg_object_to_MTEXT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MTEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MULTILEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_MULTILEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MULTILEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_MULTILEADER *)dwg_object_to_MULTILEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_MULTILEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_OLE2FRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLE2FRAME *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_OLE2FRAME" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_OLE2FRAME *)dwg_object_to_OLE2FRAME(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLE2FRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_OLEFRAME(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_OLEFRAME *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_OLEFRAME" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_OLEFRAME *)dwg_object_to_OLEFRAME(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_OLEFRAME, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PDFUNDERLAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PDFUNDERLAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PDFUNDERLAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_PDFUNDERLAY *)dwg_object_to_PDFUNDERLAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractentity_UNDERLAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POINT *)dwg_object_to_POINT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POLYLINE_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_2D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POLYLINE_2D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POLYLINE_2D *)dwg_object_to_POLYLINE_2D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POLYLINE_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_3D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POLYLINE_3D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POLYLINE_3D *)dwg_object_to_POLYLINE_3D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POLYLINE_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POLYLINE_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POLYLINE_MESH *)dwg_object_to_POLYLINE_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_MESH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POLYLINE_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POLYLINE_PFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POLYLINE_PFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POLYLINE_PFACE *)dwg_object_to_POLYLINE_PFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POLYLINE_PFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PROXY_ENTITY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PROXY_ENTITY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PROXY_ENTITY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_PROXY_ENTITY *)dwg_object_to_PROXY_ENTITY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PROXY_ENTITY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RAY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_RAY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RAY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_RAY *)dwg_object_to_RAY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_REGION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REGION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_REGION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_REGION *)dwg_object_to_REGION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_3DSOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_REPEAT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_REPEAT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_REPEAT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_REPEAT *)dwg_object_to_REPEAT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_REPEAT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SECTIONOBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SECTIONOBJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SECTIONOBJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_SECTIONOBJECT *)dwg_object_to_SECTIONOBJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SECTIONOBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SEQEND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SEQEND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SEQEND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_SEQEND *)dwg_object_to_SEQEND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SEQEND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SHAPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SHAPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SHAPE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_SHAPE *)dwg_object_to_SHAPE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SHAPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SOLID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SOLID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SOLID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_SOLID *)dwg_object_to_SOLID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SOLID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SPLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_SPLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SPLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_SPLINE *)dwg_object_to_SPLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_SPLINE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TEXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TEXT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TEXT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_TEXT *)dwg_object_to_TEXT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TEXT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TOLERANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TOLERANCE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TOLERANCE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_TOLERANCE *)dwg_object_to_TOLERANCE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TOLERANCE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TRACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_TRACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TRACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_TRACE *)dwg_object_to_TRACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_TRACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_UNKNOWN_ENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_UNKNOWN_ENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_UNKNOWN_ENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_UNKNOWN_ENT *)dwg_object_to_UNKNOWN_ENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_UNKNOWN_ENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VERTEX_2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_2D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VERTEX_2D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VERTEX_2D *)dwg_object_to_VERTEX_2D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_2D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VERTEX_3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_3D *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VERTEX_3D" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VERTEX_3D *)dwg_object_to_VERTEX_3D(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VERTEX_MESH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_MESH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VERTEX_MESH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VERTEX_MESH *)dwg_object_to_VERTEX_MESH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VERTEX_PFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VERTEX_PFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE *)dwg_object_to_VERTEX_PFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_3D, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VERTEX_PFACE_FACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VERTEX_PFACE_FACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VERTEX_PFACE_FACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VERTEX_PFACE_FACE *)dwg_object_to_VERTEX_PFACE_FACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VERTEX_PFACE_FACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VIEWPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_VIEWPORT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VIEWPORT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_VIEWPORT *)dwg_object_to_VIEWPORT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_VIEWPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_WIPEOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_WIPEOUT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_WIPEOUT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_WIPEOUT *)dwg_object_to_WIPEOUT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_WIPEOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_XLINE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_XLINE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_XLINE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_XLINE *)dwg_object_to_XLINE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_RAY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ARC_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_ARC_DIMENSION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ARC_DIMENSION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_ARC_DIMENSION *)dwg_object_to_ARC_DIMENSION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_ARC_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_HELIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_HELIX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_HELIX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_HELIX *)dwg_object_to_HELIX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_HELIX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LARGE_RADIAL_DIMENSION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LARGE_RADIAL_DIMENSION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LARGE_RADIAL_DIMENSION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LARGE_RADIAL_DIMENSION *)dwg_object_to_LARGE_RADIAL_DIMENSION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYOUTPRINTCONFIG(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_LAYOUTPRINTCONFIG *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYOUTPRINTCONFIG" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_LAYOUTPRINTCONFIG *)dwg_object_to_LAYOUTPRINTCONFIG(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_LAYOUTPRINTCONFIG, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PLANESURFACE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_PLANESURFACE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PLANESURFACE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_PLANESURFACE *)dwg_object_to_PLANESURFACE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_PLANESURFACE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POINTCLOUD *)dwg_object_to_POINTCLOUD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Entity_POINTCLOUDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Entity_POINTCLOUDEX *)dwg_object_to_POINTCLOUDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_entity_POINTCLOUDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_BOOLEAN_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOOLEAN_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_BOOLEAN_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_BOOLEAN_CLASS *)dwg_object_to_ACSH_BOOLEAN_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOOLEAN_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_BOX_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BOX_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_BOX_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_BOX_CLASS *)dwg_object_to_ACSH_BOX_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BOX_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_CONE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CONE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_CONE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_CONE_CLASS *)dwg_object_to_ACSH_CONE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CONE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_CYLINDER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CYLINDER_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_CYLINDER_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_CYLINDER_CLASS *)dwg_object_to_ACSH_CYLINDER_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CYLINDER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_FILLET_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_FILLET_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_FILLET_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_FILLET_CLASS *)dwg_object_to_ACSH_FILLET_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_FILLET_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_HISTORY_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_HISTORY_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_HISTORY_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_HISTORY_CLASS *)dwg_object_to_ACSH_HISTORY_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_HISTORY_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_SPHERE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_SPHERE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_SPHERE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_SPHERE_CLASS *)dwg_object_to_ACSH_SPHERE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_SPHERE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_TORUS_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_TORUS_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_TORUS_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_TORUS_CLASS *)dwg_object_to_ACSH_TORUS_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_TORUS_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_WEDGE_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_WEDGE_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_WEDGE_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_WEDGE_CLASS *)dwg_object_to_ACSH_WEDGE_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_WEDGE_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_APPID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_APPID" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_APPID *)dwg_object_to_APPID(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_APPID_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_APPID_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_APPID_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_APPID_CONTROL *)dwg_object_to_APPID_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_APPID_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCGEOMDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCGEOMDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCGEOMDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCGEOMDEPENDENCY *)dwg_object_to_ASSOCGEOMDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCGEOMDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCNETWORK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCNETWORK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCNETWORK *)dwg_object_to_ASSOCNETWORK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKALIGNMENTGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKALIGNMENTGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTGRIP *)dwg_object_to_BLOCKALIGNMENTGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKALIGNMENTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNMENTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKALIGNMENTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKALIGNMENTPARAMETER *)dwg_object_to_BLOCKALIGNMENTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKBASEPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKBASEPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKBASEPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKBASEPOINTPARAMETER *)dwg_object_to_BLOCKBASEPOINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKFLIPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKFLIPACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKFLIPACTION *)dwg_object_to_BLOCKFLIPACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKFLIPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKFLIPGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKFLIPGRIP *)dwg_object_to_BLOCKFLIPGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKFLIPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKFLIPPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKFLIPPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKFLIPPARAMETER *)dwg_object_to_BLOCKFLIPPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKFLIPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKGRIPLOCATIONCOMPONENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKGRIPLOCATIONCOMPONENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *)dwg_object_to_BLOCKGRIPLOCATIONCOMPONENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLINEARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLINEARGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLINEARGRIP *)dwg_object_to_BLOCKLINEARGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLOOKUPGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLOOKUPGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPGRIP *)dwg_object_to_BLOCKLOOKUPGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKMOVEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKMOVEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKMOVEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKMOVEACTION *)dwg_object_to_BLOCKMOVEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKMOVEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKROTATEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKROTATEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKROTATEACTION *)dwg_object_to_BLOCKROTATEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKROTATIONGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKROTATIONGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONGRIP *)dwg_object_to_BLOCKROTATIONGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKSCALEACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSCALEACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKSCALEACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKSCALEACTION *)dwg_object_to_BLOCKSCALEACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSCALEACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKVISIBILITYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKVISIBILITYGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYGRIP *)dwg_object_to_BLOCKVISIBILITYGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCK_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCK_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCK_CONTROL *)dwg_object_to_BLOCK_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCK_HEADER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCK_HEADER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCK_HEADER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCK_HEADER *)dwg_object_to_BLOCK_HEADER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCK_HEADER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_CELLSTYLEMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_CELLSTYLEMAP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_CELLSTYLEMAP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_CELLSTYLEMAP *)dwg_object_to_CELLSTYLEMAP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_CELLSTYLEMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DETAILVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DETAILVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DETAILVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DETAILVIEWSTYLE *)dwg_object_to_DETAILVIEWSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DETAILVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DICTIONARY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DICTIONARY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DICTIONARY *)dwg_object_to_DICTIONARY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DICTIONARYVAR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYVAR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DICTIONARYVAR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DICTIONARYVAR *)dwg_object_to_DICTIONARYVAR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYVAR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DICTIONARYWDFLT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DICTIONARYWDFLT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DICTIONARYWDFLT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DICTIONARYWDFLT *)dwg_object_to_DICTIONARYWDFLT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DICTIONARYWDFLT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DIMSTYLE *)dwg_object_to_DIMSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DIMSTYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DIMSTYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DIMSTYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DIMSTYLE_CONTROL *)dwg_object_to_DIMSTYLE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DIMSTYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DUMMY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DUMMY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DUMMY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DUMMY *)dwg_object_to_DUMMY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DUMMY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DYNAMICBLOCKPURGEPREVENTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DYNAMICBLOCKPURGEPREVENTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *)dwg_object_to_DYNAMICBLOCKPURGEPREVENTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_FIELD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_FIELD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_FIELD *)dwg_object_to_FIELD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_FIELDLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FIELDLIST *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_FIELDLIST" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_FIELDLIST *)dwg_object_to_FIELDLIST(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FIELDLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_GEODATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GEODATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_GEODATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_GEODATA *)dwg_object_to_GEODATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GEODATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_GROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_GROUP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_GROUP *)dwg_object_to_GROUP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IDBUFFER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IDBUFFER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IDBUFFER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_IDBUFFER *)dwg_object_to_IDBUFFER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IDBUFFER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IMAGEDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IMAGEDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_IMAGEDEF *)dwg_object_to_IMAGEDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IMAGEDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGEDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IMAGEDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_IMAGEDEF_REACTOR *)dwg_object_to_IMAGEDEF_REACTOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGEDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_INDEX *)dwg_object_to_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LAYER *)dwg_object_to_LAYER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYERFILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYERFILTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYERFILTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LAYERFILTER *)dwg_object_to_LAYERFILTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYERFILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYER_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYER_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LAYER_CONTROL *)dwg_object_to_LAYER_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYER_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYER_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYER_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LAYER_INDEX *)dwg_object_to_LAYER_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYER_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LAYOUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LAYOUT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LAYOUT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LAYOUT *)dwg_object_to_LAYOUT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LAYOUT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LONG_TRANSACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LONG_TRANSACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LONG_TRANSACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LONG_TRANSACTION *)dwg_object_to_LONG_TRANSACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LONG_TRANSACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LTYPE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LTYPE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LTYPE *)dwg_object_to_LTYPE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LTYPE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LTYPE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LTYPE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LTYPE_CONTROL *)dwg_object_to_LTYPE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LTYPE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MLINESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLINESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MLINESTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_MLINESTYLE *)dwg_object_to_MLINESTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLINESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PLACEHOLDER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLACEHOLDER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PLACEHOLDER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_PLACEHOLDER *)dwg_object_to_PLACEHOLDER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLACEHOLDER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PLOTSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PLOTSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PLOTSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_PLOTSETTINGS *)dwg_object_to_PLOTSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PLOTSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RASTERVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RASTERVARIABLES *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RASTERVARIABLES" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RASTERVARIABLES *)dwg_object_to_RASTERVARIABLES(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RASTERVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RENDERENVIRONMENT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENVIRONMENT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RENDERENVIRONMENT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RENDERENVIRONMENT *)dwg_object_to_RENDERENVIRONMENT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENVIRONMENT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SCALE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SCALE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SCALE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SCALE *)dwg_object_to_SCALE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SCALE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SECTIONVIEWSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTIONVIEWSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SECTIONVIEWSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SECTIONVIEWSTYLE *)dwg_object_to_SECTIONVIEWSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTIONVIEWSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SECTION_MANAGER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_MANAGER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SECTION_MANAGER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SECTION_MANAGER *)dwg_object_to_SECTION_MANAGER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_MANAGER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SORTENTSTABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SORTENTSTABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SORTENTSTABLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SORTENTSTABLE *)dwg_object_to_SORTENTSTABLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SORTENTSTABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SPATIAL_FILTER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_FILTER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SPATIAL_FILTER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SPATIAL_FILTER *)dwg_object_to_SPATIAL_FILTER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_FILTER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_STYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_STYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_STYLE *)dwg_object_to_STYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_STYLE_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_STYLE_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_STYLE_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_STYLE_CONTROL *)dwg_object_to_STYLE_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_STYLE_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SUN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SUN *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SUN" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SUN *)dwg_object_to_SUN(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SUN, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TABLEGEOMETRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLEGEOMETRY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TABLEGEOMETRY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_TABLEGEOMETRY *)dwg_object_to_TABLEGEOMETRY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLEGEOMETRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_UCS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_UCS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_UCS *)dwg_object_to_UCS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_UCS_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UCS_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_UCS_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_UCS_CONTROL *)dwg_object_to_UCS_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UCS_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_UNKNOWN_OBJ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_UNKNOWN_OBJ *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_UNKNOWN_OBJ" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_UNKNOWN_OBJ *)dwg_object_to_UNKNOWN_OBJ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_UNKNOWN_OBJ, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VBA_PROJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VBA_PROJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VBA_PROJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VBA_PROJECT *)dwg_object_to_VBA_PROJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VBA_PROJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VIEW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VIEW" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VIEW *)dwg_object_to_VIEW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VIEW_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VIEW_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VIEW_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VIEW_CONTROL *)dwg_object_to_VIEW_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VIEW_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VISUALSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VISUALSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VISUALSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VISUALSTYLE *)dwg_object_to_VISUALSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VISUALSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VPORT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VPORT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VPORT *)dwg_object_to_VPORT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VPORT_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VPORT_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VPORT_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VPORT_CONTROL *)dwg_object_to_VPORT_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VPORT_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VX_CONTROL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_CONTROL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VX_CONTROL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VX_CONTROL *)dwg_object_to_VX_CONTROL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_CONTROL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_VX_TABLE_RECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_VX_TABLE_RECORD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_VX_TABLE_RECORD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_VX_TABLE_RECORD *)dwg_object_to_VX_TABLE_RECORD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_VX_TABLE_RECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_WIPEOUTVARIABLES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_WIPEOUTVARIABLES *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_WIPEOUTVARIABLES" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_WIPEOUTVARIABLES *)dwg_object_to_WIPEOUTVARIABLES(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_WIPEOUTVARIABLES, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_XRECORD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_XRECORD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_XRECORD" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_XRECORD *)dwg_object_to_XRECORD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_XRECORD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PDFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PDFDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PDFDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_PDFDEFINITION *)dwg_object_to_PDFDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DGNDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DGNDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DGNDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DGNDEFINITION *)dwg_object_to_DGNDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DWFDEFINITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DWFDEFINITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DWFDEFINITION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DWFDEFINITION *)dwg_object_to_DWFDEFINITION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_UNDERLAYDEFINITION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_BREP_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_BREP_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_BREP_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_BREP_CLASS *)dwg_object_to_ACSH_BREP_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_BREP_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_CHAMFER_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_CHAMFER_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_CHAMFER_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_CHAMFER_CLASS *)dwg_object_to_ACSH_CHAMFER_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_CHAMFER_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ACSH_PYRAMID_CLASS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ACSH_PYRAMID_CLASS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ACSH_PYRAMID_CLASS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ACSH_PYRAMID_CLASS *)dwg_object_to_ACSH_PYRAMID_CLASS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ACSH_PYRAMID_CLASS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ALDIMOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ALDIMOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ALDIMOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ALDIMOBJECTCONTEXTDATA *)dwg_object_to_ALDIMOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOC2DCONSTRAINTGROUP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOC2DCONSTRAINTGROUP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOC2DCONSTRAINTGROUP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOC2DCONSTRAINTGROUP *)dwg_object_to_ASSOC2DCONSTRAINTGROUP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCACTION *)dwg_object_to_ASSOCACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCACTIONPARAM *)dwg_object_to_ASSOCACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCARRAYACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCARRAYACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCARRAYACTIONBODY *)dwg_object_to_ASSOCARRAYACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCARRAYACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCASMBODYACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCASMBODYACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCASMBODYACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCASMBODYACTIONPARAM *)dwg_object_to_ASSOCASMBODYACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCBLENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCBLENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *)dwg_object_to_ASSOCBLENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCCOMPOUNDACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCCOMPOUNDACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *)dwg_object_to_ASSOCCOMPOUNDACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCDEPENDENCY *)dwg_object_to_ASSOCDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCDIMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCDIMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCDIMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCDIMDEPENDENCYBODY *)dwg_object_to_ASSOCDIMDEPENDENCYBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCEXTENDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCEXTENDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *)dwg_object_to_ASSOCEXTENDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCEXTRUDEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCEXTRUDEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *)dwg_object_to_ASSOCEXTRUDEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCFACEACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFACEACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCFACEACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCFACEACTIONPARAM *)dwg_object_to_ASSOCFACEACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFACEACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCFILLETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCFILLETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *)dwg_object_to_ASSOCFILLETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCLOFTEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCLOFTEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *)dwg_object_to_ASSOCLOFTEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCNETWORKSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCNETWORKSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *)dwg_object_to_ASSOCNETWORKSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCOBJECTACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOBJECTACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCOBJECTACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCOBJECTACTIONPARAM *)dwg_object_to_ASSOCOBJECTACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCOFFSETSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCOFFSETSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *)dwg_object_to_ASSOCOFFSETSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCOSNAPPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCOSNAPPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *)dwg_object_to_ASSOCOSNAPPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCPATCHSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCPATCHSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *)dwg_object_to_ASSOCPATCHSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCPATHACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPATHACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCPATHACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCPATHACTIONPARAM *)dwg_object_to_ASSOCPATHACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPATHACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCPLANESURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPLANESURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCPLANESURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCPLANESURFACEACTIONBODY *)dwg_object_to_ASSOCPLANESURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCPOINTREFACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCPOINTREFACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCPOINTREFACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCPOINTREFACTIONPARAM *)dwg_object_to_ASSOCPOINTREFACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCREVOLVEDSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCREVOLVEDSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *)dwg_object_to_ASSOCREVOLVEDSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCTRIMSURFACEACTIONBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCTRIMSURFACEACTIONBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *)dwg_object_to_ASSOCTRIMSURFACEACTIONBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCVALUEDEPENDENCY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVALUEDEPENDENCY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCVALUEDEPENDENCY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCVALUEDEPENDENCY *)dwg_object_to_ASSOCVALUEDEPENDENCY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVALUEDEPENDENCY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCVARIABLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVARIABLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCVARIABLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCVARIABLE *)dwg_object_to_ASSOCVARIABLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVARIABLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCVERTEXACTIONPARAM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCVERTEXACTIONPARAM *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCVERTEXACTIONPARAM" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCVERTEXACTIONPARAM *)dwg_object_to_ASSOCVERTEXACTIONPARAM(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLKREFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLKREFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLKREFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLKREFOBJECTCONTEXTDATA *)dwg_object_to_BLKREFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKALIGNEDCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKALIGNEDCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *)dwg_object_to_BLOCKALIGNEDCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKANGULARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKANGULARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *)dwg_object_to_BLOCKANGULARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKARRAYACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKARRAYACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKARRAYACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKARRAYACTION *)dwg_object_to_BLOCKARRAYACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKARRAYACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKDIAMETRICCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKDIAMETRICCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *)dwg_object_to_BLOCKDIAMETRICCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKHORIZONTALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKHORIZONTALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *)dwg_object_to_BLOCKHORIZONTALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLINEARCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLINEARCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *)dwg_object_to_BLOCKLINEARCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLINEARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLINEARPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLINEARPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLINEARPARAMETER *)dwg_object_to_BLOCKLINEARPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLINEARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLOOKUPACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLOOKUPACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPACTION *)dwg_object_to_BLOCKLOOKUPACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKLOOKUPPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKLOOKUPPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKLOOKUPPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKLOOKUPPARAMETER *)dwg_object_to_BLOCKLOOKUPPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKLOOKUPPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKPARAMDEPENDENCYBODY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPARAMDEPENDENCYBODY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKPARAMDEPENDENCYBODY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKPARAMDEPENDENCYBODY *)dwg_object_to_BLOCKPARAMDEPENDENCYBODY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKPOINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKPOINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKPOINTPARAMETER *)dwg_object_to_BLOCKPOINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKPOLARGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKPOLARGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKPOLARGRIP *)dwg_object_to_BLOCKPOLARGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKPOLARPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKPOLARPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKPOLARPARAMETER *)dwg_object_to_BLOCKPOLARPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKPOLARSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKPOLARSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKPOLARSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKPOLARSTRETCHACTION *)dwg_object_to_BLOCKPOLARSTRETCHACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKRADIALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKRADIALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *)dwg_object_to_BLOCKRADIALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKREPRESENTATION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKREPRESENTATION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKREPRESENTATION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKREPRESENTATION *)dwg_object_to_BLOCKREPRESENTATION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKREPRESENTATION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKROTATIONPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKROTATIONPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKROTATIONPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKROTATIONPARAMETER *)dwg_object_to_BLOCKROTATIONPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKROTATIONPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKSTRETCHACTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKSTRETCHACTION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKSTRETCHACTION" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKSTRETCHACTION *)dwg_object_to_BLOCKSTRETCHACTION(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKSTRETCHACTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKUSERPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKUSERPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKUSERPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKUSERPARAMETER *)dwg_object_to_BLOCKUSERPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKUSERPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKVERTICALCONSTRAINTPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKVERTICALCONSTRAINTPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *)dwg_object_to_BLOCKVERTICALCONSTRAINTPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKVISIBILITYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKVISIBILITYPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKVISIBILITYPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKVISIBILITYPARAMETER *)dwg_object_to_BLOCKVISIBILITYPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKXYGRIP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYGRIP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKXYGRIP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKXYGRIP *)dwg_object_to_BLOCKXYGRIP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYGRIP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_BLOCKXYPARAMETER(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_BLOCKXYPARAMETER *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_BLOCKXYPARAMETER" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_BLOCKXYPARAMETER *)dwg_object_to_BLOCKXYPARAMETER(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_BLOCKXYPARAMETER, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DATALINK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DATALINK *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DATALINK" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DATALINK *)dwg_object_to_DATALINK(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DATALINK, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_DBCOLOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_DBCOLOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_DBCOLOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_DBCOLOR *)dwg_object_to_DBCOLOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_DBCOLOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_EVALUATION_GRAPH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_EVALUATION_GRAPH *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_EVALUATION_GRAPH" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_EVALUATION_GRAPH *)dwg_object_to_EVALUATION_GRAPH(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_EVALUATION_GRAPH, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_FCFOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_FCFOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_FCFOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_FCFOBJECTCONTEXTDATA *)dwg_object_to_FCFOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_FCFOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_GRADIENT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GRADIENT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_GRADIENT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_GRADIENT_BACKGROUND *)dwg_object_to_GRADIENT_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GRADIENT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_GROUND_PLANE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_GROUND_PLANE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_GROUND_PLANE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_GROUND_PLANE_BACKGROUND *)dwg_object_to_GROUND_PLANE_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_GROUND_PLANE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IBL_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IBL_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IBL_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_IBL_BACKGROUND *)dwg_object_to_IBL_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IBL_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_IMAGE_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_IMAGE_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_IMAGE_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_IMAGE_BACKGROUND *)dwg_object_to_IMAGE_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_IMAGE_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LEADEROBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LEADEROBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LEADEROBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LEADEROBJECTCONTEXTDATA *)dwg_object_to_LEADEROBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_LIGHTLIST(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_LIGHTLIST *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_LIGHTLIST" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_LIGHTLIST *)dwg_object_to_LIGHTLIST(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_LIGHTLIST, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MATERIAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MATERIAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MATERIAL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_MATERIAL *)dwg_object_to_MATERIAL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MATERIAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MENTALRAYRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MENTALRAYRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MENTALRAYRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_MENTALRAYRENDERSETTINGS *)dwg_object_to_MENTALRAYRENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MENTALRAYRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MLEADERSTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MLEADERSTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MLEADERSTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_MLEADERSTYLE *)dwg_object_to_MLEADERSTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MLEADERSTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_MTEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_MTEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_MTEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_MTEXTOBJECTCONTEXTDATA *)dwg_object_to_MTEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_OBJECT_PTR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_OBJECT_PTR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_OBJECT_PTR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_OBJECT_PTR *)dwg_object_to_OBJECT_PTR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_OBJECT_PTR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PARTIAL_VIEWING_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PARTIAL_VIEWING_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PARTIAL_VIEWING_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_PARTIAL_VIEWING_INDEX *)dwg_object_to_PARTIAL_VIEWING_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PARTIAL_VIEWING_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDCOLORMAP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDCOLORMAP *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDCOLORMAP" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_POINTCLOUDCOLORMAP *)dwg_object_to_POINTCLOUDCOLORMAP(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDCOLORMAP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDDEF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDDEF" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF *)dwg_object_to_POINTCLOUDDEF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDDEFEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEFEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDDEFEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEFEX *)dwg_object_to_POINTCLOUDDEFEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEFEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDDEF_REACTOR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDDEF_REACTOR" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR *)dwg_object_to_POINTCLOUDDEF_REACTOR(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_POINTCLOUDDEF_REACTOR_EX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_POINTCLOUDDEF_REACTOR_EX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_POINTCLOUDDEF_REACTOR_EX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_POINTCLOUDDEF_REACTOR_EX *)dwg_object_to_POINTCLOUDDEF_REACTOR_EX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_PROXY_OBJECT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_PROXY_OBJECT *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_PROXY_OBJECT" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_PROXY_OBJECT *)dwg_object_to_PROXY_OBJECT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_PROXY_OBJECT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RAPIDRTRENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RAPIDRTRENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RAPIDRTRENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RAPIDRTRENDERSETTINGS *)dwg_object_to_RAPIDRTRENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RAPIDRTRENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RENDERENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERENTRY *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RENDERENTRY" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RENDERENTRY *)dwg_object_to_RENDERENTRY(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERENTRY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RENDERGLOBAL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERGLOBAL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RENDERGLOBAL" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RENDERGLOBAL *)dwg_object_to_RENDERGLOBAL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERGLOBAL, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_RENDERSETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_RENDERSETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_RENDERSETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_RENDERSETTINGS *)dwg_object_to_RENDERSETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_RENDERSETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SECTION_SETTINGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SECTION_SETTINGS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SECTION_SETTINGS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SECTION_SETTINGS *)dwg_object_to_SECTION_SETTINGS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SECTION_SETTINGS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SKYLIGHT_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SKYLIGHT_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SKYLIGHT_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SKYLIGHT_BACKGROUND *)dwg_object_to_SKYLIGHT_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SKYLIGHT_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SOLID_BACKGROUND(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SOLID_BACKGROUND *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SOLID_BACKGROUND" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SOLID_BACKGROUND *)dwg_object_to_SOLID_BACKGROUND(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SOLID_BACKGROUND, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_SPATIAL_INDEX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_SPATIAL_INDEX *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_SPATIAL_INDEX" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_SPATIAL_INDEX *)dwg_object_to_SPATIAL_INDEX(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_SPATIAL_INDEX, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TABLESTYLE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TABLESTYLE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TABLESTYLE" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_TABLESTYLE *)dwg_object_to_TABLESTYLE(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TABLESTYLE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_TEXTOBJECTCONTEXTDATA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_TEXTOBJECTCONTEXTDATA *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_TEXTOBJECTCONTEXTDATA" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_TEXTOBJECTCONTEXTDATA *)dwg_object_to_TEXTOBJECTCONTEXTDATA(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCARRAYMODIFYPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCARRAYMODIFYPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *)dwg_object_to_ASSOCARRAYMODIFYPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCARRAYPATHPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPATHPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCARRAYPATHPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPATHPARAMETERS *)dwg_object_to_ASSOCARRAYPATHPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCARRAYPOLARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYPOLARPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCARRAYPOLARPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCARRAYPOLARPARAMETERS *)dwg_object_to_ASSOCARRAYPOLARPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dwg_object_to_ASSOCARRAYRECTANGULARPARAMETERS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dwg_Object *arg1 = (Dwg_Object *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__dwg_object, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dwg_object_to_ASSOCARRAYRECTANGULARPARAMETERS" "', argument " "1"" of type '" "Dwg_Object *""'"); 
  }
  arg1 = (Dwg_Object *)(argp1);
  result = (Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *)dwg_object_to_ASSOCARRAYRECTANGULARPARAMETERS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { "new_Dwg_Object_Array", _wrap_new_Dwg_Object_Array, METH_O, NULL},
	 { "delete_Dwg_Object_Array", _wrap_delete_Dwg_Object_Array, METH_O, NULL},
	 { "Dwg_Object_Array_getitem", _wrap_Dwg_Object_Array_getitem, METH_VARARGS, NULL},
	 { "Dwg_Object_Array_setitem", _wrap_Dwg_Object_Array_setitem, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_TimeBLL_days_set", _wrap_Dwg_Bitcode_TimeBLL_days_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_TimeBLL_days_get", _wrap_Dwg_Bitcode_TimeBLL_days_get, METH_O, NULL},
	 { "Dwg_Bitcode_TimeBLL_ms_set", _wrap_Dwg_Bitcode_TimeBLL_ms_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_TimeBLL_ms_get", _wrap_Dwg_Bitcode_TimeBLL_ms_get, METH_O, NULL},
	 { "Dwg_Bitcode_TimeBLL_value_set", _wrap_Dwg_Bitcode_TimeBLL_value_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_TimeBLL_value_get", _wrap_Dwg_Bitcode_TimeBLL_value_get, METH_O, NULL},
	 { "new_Dwg_Bitcode_TimeBLL", _wrap_new_Dwg_Bitcode_TimeBLL, METH_NOARGS, NULL},
	 { "delete_Dwg_Bitcode_TimeBLL", _wrap_delete_Dwg_Bitcode_TimeBLL, METH_O, NULL},
	 { "Dwg_Bitcode_TimeBLL_swigregister", Dwg_Bitcode_TimeBLL_swigregister, METH_O, NULL},
	 { "Dwg_Bitcode_TimeBLL_swiginit", Dwg_Bitcode_TimeBLL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2RD_x_set", _wrap_Dwg_Bitcode_2RD_x_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2RD_x_get", _wrap_Dwg_Bitcode_2RD_x_get, METH_O, NULL},
	 { "Dwg_Bitcode_2RD_y_set", _wrap_Dwg_Bitcode_2RD_y_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2RD_y_get", _wrap_Dwg_Bitcode_2RD_y_get, METH_O, NULL},
	 { "new_Dwg_Bitcode_2RD", _wrap_new_Dwg_Bitcode_2RD, METH_NOARGS, NULL},
	 { "delete_Dwg_Bitcode_2RD", _wrap_delete_Dwg_Bitcode_2RD, METH_O, NULL},
	 { "Dwg_Bitcode_2RD_swigregister", Dwg_Bitcode_2RD_swigregister, METH_O, NULL},
	 { "Dwg_Bitcode_2RD_swiginit", Dwg_Bitcode_2RD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2BD_x_set", _wrap_Dwg_Bitcode_2BD_x_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2BD_x_get", _wrap_Dwg_Bitcode_2BD_x_get, METH_O, NULL},
	 { "Dwg_Bitcode_2BD_y_set", _wrap_Dwg_Bitcode_2BD_y_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_2BD_y_get", _wrap_Dwg_Bitcode_2BD_y_get, METH_O, NULL},
	 { "new_Dwg_Bitcode_2BD", _wrap_new_Dwg_Bitcode_2BD, METH_NOARGS, NULL},
	 { "delete_Dwg_Bitcode_2BD", _wrap_delete_Dwg_Bitcode_2BD, METH_O, NULL},
	 { "Dwg_Bitcode_2BD_swigregister", Dwg_Bitcode_2BD_swigregister, METH_O, NULL},
	 { "Dwg_Bitcode_2BD_swiginit", Dwg_Bitcode_2BD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3RD_x_set", _wrap_Dwg_Bitcode_3RD_x_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3RD_x_get", _wrap_Dwg_Bitcode_3RD_x_get, METH_O, NULL},
	 { "Dwg_Bitcode_3RD_y_set", _wrap_Dwg_Bitcode_3RD_y_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3RD_y_get", _wrap_Dwg_Bitcode_3RD_y_get, METH_O, NULL},
	 { "Dwg_Bitcode_3RD_z_set", _wrap_Dwg_Bitcode_3RD_z_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3RD_z_get", _wrap_Dwg_Bitcode_3RD_z_get, METH_O, NULL},
	 { "new_Dwg_Bitcode_3RD", _wrap_new_Dwg_Bitcode_3RD, METH_NOARGS, NULL},
	 { "delete_Dwg_Bitcode_3RD", _wrap_delete_Dwg_Bitcode_3RD, METH_O, NULL},
	 { "Dwg_Bitcode_3RD_swigregister", Dwg_Bitcode_3RD_swigregister, METH_O, NULL},
	 { "Dwg_Bitcode_3RD_swiginit", Dwg_Bitcode_3RD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3BD_x_set", _wrap_Dwg_Bitcode_3BD_x_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3BD_x_get", _wrap_Dwg_Bitcode_3BD_x_get, METH_O, NULL},
	 { "Dwg_Bitcode_3BD_y_set", _wrap_Dwg_Bitcode_3BD_y_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3BD_y_get", _wrap_Dwg_Bitcode_3BD_y_get, METH_O, NULL},
	 { "Dwg_Bitcode_3BD_z_set", _wrap_Dwg_Bitcode_3BD_z_set, METH_VARARGS, NULL},
	 { "Dwg_Bitcode_3BD_z_get", _wrap_Dwg_Bitcode_3BD_z_get, METH_O, NULL},
	 { "new_Dwg_Bitcode_3BD", _wrap_new_Dwg_Bitcode_3BD, METH_NOARGS, NULL},
	 { "delete_Dwg_Bitcode_3BD", _wrap_delete_Dwg_Bitcode_3BD, METH_O, NULL},
	 { "Dwg_Bitcode_3BD_swigregister", Dwg_Bitcode_3BD_swigregister, METH_O, NULL},
	 { "Dwg_Bitcode_3BD_swiginit", Dwg_Bitcode_3BD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Versions_r_set", _wrap_Dwg_Versions_r_set, METH_VARARGS, NULL},
	 { "Dwg_Versions_r_get", _wrap_Dwg_Versions_r_get, METH_O, NULL},
	 { "Dwg_Versions_type_get", _wrap_Dwg_Versions_type_get, METH_O, NULL},
	 { "Dwg_Versions_hdr_get", _wrap_Dwg_Versions_hdr_get, METH_O, NULL},
	 { "Dwg_Versions_desc_get", _wrap_Dwg_Versions_desc_get, METH_O, NULL},
	 { "Dwg_Versions_dwg_version_set", _wrap_Dwg_Versions_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Versions_dwg_version_get", _wrap_Dwg_Versions_dwg_version_get, METH_O, NULL},
	 { "new_Dwg_Versions", _wrap_new_Dwg_Versions, METH_NOARGS, NULL},
	 { "delete_Dwg_Versions", _wrap_delete_Dwg_Versions, METH_O, NULL},
	 { "Dwg_Versions_swigregister", Dwg_Versions_swigregister, METH_O, NULL},
	 { "Dwg_Versions_swiginit", Dwg_Versions_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Handle_code_set", _wrap_Dwg_Handle_code_set, METH_VARARGS, NULL},
	 { "Dwg_Handle_code_get", _wrap_Dwg_Handle_code_get, METH_O, NULL},
	 { "Dwg_Handle_size_set", _wrap_Dwg_Handle_size_set, METH_VARARGS, NULL},
	 { "Dwg_Handle_size_get", _wrap_Dwg_Handle_size_get, METH_O, NULL},
	 { "Dwg_Handle_value_set", _wrap_Dwg_Handle_value_set, METH_VARARGS, NULL},
	 { "Dwg_Handle_value_get", _wrap_Dwg_Handle_value_get, METH_O, NULL},
	 { "Dwg_Handle_is_global_set", _wrap_Dwg_Handle_is_global_set, METH_VARARGS, NULL},
	 { "Dwg_Handle_is_global_get", _wrap_Dwg_Handle_is_global_get, METH_O, NULL},
	 { "new_Dwg_Handle", _wrap_new_Dwg_Handle, METH_NOARGS, NULL},
	 { "delete_Dwg_Handle", _wrap_delete_Dwg_Handle, METH_O, NULL},
	 { "Dwg_Handle_swigregister", Dwg_Handle_swigregister, METH_O, NULL},
	 { "Dwg_Handle_swiginit", Dwg_Handle_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_Ref_obj_set", _wrap_Dwg_Object_Ref_obj_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Ref_obj_get", _wrap_Dwg_Object_Ref_obj_get, METH_O, NULL},
	 { "Dwg_Object_Ref_handleref_set", _wrap_Dwg_Object_Ref_handleref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Ref_handleref_get", _wrap_Dwg_Object_Ref_handleref_get, METH_O, NULL},
	 { "Dwg_Object_Ref_absolute_ref_set", _wrap_Dwg_Object_Ref_absolute_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Ref_absolute_ref_get", _wrap_Dwg_Object_Ref_absolute_ref_get, METH_O, NULL},
	 { "Dwg_Object_Ref_r11_idx_set", _wrap_Dwg_Object_Ref_r11_idx_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Ref_r11_idx_get", _wrap_Dwg_Object_Ref_r11_idx_get, METH_O, NULL},
	 { "new_Dwg_Object_Ref", _wrap_new_Dwg_Object_Ref, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_Ref", _wrap_delete_Dwg_Object_Ref, METH_O, NULL},
	 { "Dwg_Object_Ref_swigregister", Dwg_Object_Ref_swigregister, METH_O, NULL},
	 { "Dwg_Object_Ref_swiginit", Dwg_Object_Ref_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Color_index_set", _wrap_Dwg_Color_index_set, METH_VARARGS, NULL},
	 { "Dwg_Color_index_get", _wrap_Dwg_Color_index_get, METH_O, NULL},
	 { "Dwg_Color_flag_set", _wrap_Dwg_Color_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Color_flag_get", _wrap_Dwg_Color_flag_get, METH_O, NULL},
	 { "Dwg_Color_raw_set", _wrap_Dwg_Color_raw_set, METH_VARARGS, NULL},
	 { "Dwg_Color_raw_get", _wrap_Dwg_Color_raw_get, METH_O, NULL},
	 { "Dwg_Color_rgb_set", _wrap_Dwg_Color_rgb_set, METH_VARARGS, NULL},
	 { "Dwg_Color_rgb_get", _wrap_Dwg_Color_rgb_get, METH_O, NULL},
	 { "Dwg_Color_method_set", _wrap_Dwg_Color_method_set, METH_VARARGS, NULL},
	 { "Dwg_Color_method_get", _wrap_Dwg_Color_method_get, METH_O, NULL},
	 { "Dwg_Color_name_set", _wrap_Dwg_Color_name_set, METH_VARARGS, NULL},
	 { "Dwg_Color_name_get", _wrap_Dwg_Color_name_get, METH_O, NULL},
	 { "Dwg_Color_book_name_set", _wrap_Dwg_Color_book_name_set, METH_VARARGS, NULL},
	 { "Dwg_Color_book_name_get", _wrap_Dwg_Color_book_name_get, METH_O, NULL},
	 { "Dwg_Color_handle_set", _wrap_Dwg_Color_handle_set, METH_VARARGS, NULL},
	 { "Dwg_Color_handle_get", _wrap_Dwg_Color_handle_get, METH_O, NULL},
	 { "Dwg_Color_alpha_raw_set", _wrap_Dwg_Color_alpha_raw_set, METH_VARARGS, NULL},
	 { "Dwg_Color_alpha_raw_get", _wrap_Dwg_Color_alpha_raw_get, METH_O, NULL},
	 { "Dwg_Color_alpha_type_set", _wrap_Dwg_Color_alpha_type_set, METH_VARARGS, NULL},
	 { "Dwg_Color_alpha_type_get", _wrap_Dwg_Color_alpha_type_get, METH_O, NULL},
	 { "Dwg_Color_alpha_set", _wrap_Dwg_Color_alpha_set, METH_VARARGS, NULL},
	 { "Dwg_Color_alpha_get", _wrap_Dwg_Color_alpha_get, METH_O, NULL},
	 { "new_Dwg_Color", _wrap_new_Dwg_Color, METH_NOARGS, NULL},
	 { "delete_Dwg_Color", _wrap_delete_Dwg_Color, METH_O, NULL},
	 { "Dwg_Color_swigregister", Dwg_Color_swigregister, METH_O, NULL},
	 { "Dwg_Color_swiginit", Dwg_Color_swiginit, METH_VARARGS, NULL},
	 { "dwg_color_method_name", _wrap_dwg_color_method_name, METH_O, NULL},
	 { "_dwg_binary_chunk_size_set", _wrap__dwg_binary_chunk_size_set, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_size_get", _wrap__dwg_binary_chunk_size_get, METH_O, NULL},
	 { "_dwg_binary_chunk_codepage_set", _wrap__dwg_binary_chunk_codepage_set, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_codepage_get", _wrap__dwg_binary_chunk_codepage_get, METH_O, NULL},
	 { "_dwg_binary_chunk_is_tu_set", _wrap__dwg_binary_chunk_is_tu_set, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_is_tu_get", _wrap__dwg_binary_chunk_is_tu_get, METH_O, NULL},
	 { "_dwg_binary_chunk_u_get", _wrap__dwg_binary_chunk_u_get, METH_O, NULL},
	 { "new__dwg_binary_chunk", _wrap_new__dwg_binary_chunk, METH_NOARGS, NULL},
	 { "delete__dwg_binary_chunk", _wrap_delete__dwg_binary_chunk, METH_O, NULL},
	 { "_dwg_binary_chunk_swigregister", _dwg_binary_chunk_swigregister, METH_O, NULL},
	 { "_dwg_binary_chunk_swiginit", _dwg_binary_chunk_swiginit, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_u_data_set", _wrap__dwg_binary_chunk_u_data_set, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_u_data_get", _wrap__dwg_binary_chunk_u_data_get, METH_O, NULL},
	 { "_dwg_binary_chunk_u_wdata_set", _wrap__dwg_binary_chunk_u_wdata_set, METH_VARARGS, NULL},
	 { "_dwg_binary_chunk_u_wdata_get", _wrap__dwg_binary_chunk_u_wdata_get, METH_O, NULL},
	 { "new__dwg_binary_chunk_u", _wrap_new__dwg_binary_chunk_u, METH_NOARGS, NULL},
	 { "delete__dwg_binary_chunk_u", _wrap_delete__dwg_binary_chunk_u, METH_O, NULL},
	 { "_dwg_binary_chunk_u_swigregister", _dwg_binary_chunk_u_swigregister, METH_O, NULL},
	 { "_dwg_binary_chunk_u_swiginit", _dwg_binary_chunk_u_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Resbuf_type_set", _wrap_Dwg_Resbuf_type_set, METH_VARARGS, NULL},
	 { "Dwg_Resbuf_type_get", _wrap_Dwg_Resbuf_type_get, METH_O, NULL},
	 { "Dwg_Resbuf_value_get", _wrap_Dwg_Resbuf_value_get, METH_O, NULL},
	 { "Dwg_Resbuf_nextrb_set", _wrap_Dwg_Resbuf_nextrb_set, METH_VARARGS, NULL},
	 { "Dwg_Resbuf_nextrb_get", _wrap_Dwg_Resbuf_nextrb_get, METH_O, NULL},
	 { "new_Dwg_Resbuf", _wrap_new_Dwg_Resbuf, METH_NOARGS, NULL},
	 { "delete_Dwg_Resbuf", _wrap_delete_Dwg_Resbuf, METH_O, NULL},
	 { "Dwg_Resbuf_swigregister", Dwg_Resbuf_swigregister, METH_O, NULL},
	 { "Dwg_Resbuf_swiginit", Dwg_Resbuf_swiginit, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_pt_set", _wrap__dwg_resbuf_value_pt_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_pt_get", _wrap__dwg_resbuf_value_pt_get, METH_O, NULL},
	 { "_dwg_resbuf_value_i8_set", _wrap__dwg_resbuf_value_i8_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_i8_get", _wrap__dwg_resbuf_value_i8_get, METH_O, NULL},
	 { "_dwg_resbuf_value_i16_set", _wrap__dwg_resbuf_value_i16_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_i16_get", _wrap__dwg_resbuf_value_i16_get, METH_O, NULL},
	 { "_dwg_resbuf_value_i32_set", _wrap__dwg_resbuf_value_i32_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_i32_get", _wrap__dwg_resbuf_value_i32_get, METH_O, NULL},
	 { "_dwg_resbuf_value_i64_set", _wrap__dwg_resbuf_value_i64_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_i64_get", _wrap__dwg_resbuf_value_i64_get, METH_O, NULL},
	 { "_dwg_resbuf_value_absref_set", _wrap__dwg_resbuf_value_absref_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_absref_get", _wrap__dwg_resbuf_value_absref_get, METH_O, NULL},
	 { "_dwg_resbuf_value_dbl_set", _wrap__dwg_resbuf_value_dbl_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_dbl_get", _wrap__dwg_resbuf_value_dbl_get, METH_O, NULL},
	 { "_dwg_resbuf_value_str_set", _wrap__dwg_resbuf_value_str_set, METH_VARARGS, NULL},
	 { "_dwg_resbuf_value_str_get", _wrap__dwg_resbuf_value_str_get, METH_O, NULL},
	 { "new__dwg_resbuf_value", _wrap_new__dwg_resbuf_value, METH_NOARGS, NULL},
	 { "delete__dwg_resbuf_value", _wrap_delete__dwg_resbuf_value, METH_O, NULL},
	 { "_dwg_resbuf_value_swigregister", _dwg_resbuf_value_swigregister, METH_O, NULL},
	 { "_dwg_resbuf_value_swiginit", _dwg_resbuf_value_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_size_set", _wrap_Dwg_Header_Variables_size_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_size_get", _wrap_Dwg_Header_Variables_size_get, METH_O, NULL},
	 { "Dwg_Header_Variables_bitsize_hi_set", _wrap_Dwg_Header_Variables_bitsize_hi_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_bitsize_hi_get", _wrap_Dwg_Header_Variables_bitsize_hi_get, METH_O, NULL},
	 { "Dwg_Header_Variables_bitsize_set", _wrap_Dwg_Header_Variables_bitsize_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_bitsize_get", _wrap_Dwg_Header_Variables_bitsize_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ACADMAINTVER_set", _wrap_Dwg_Header_Variables_ACADMAINTVER_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ACADMAINTVER_get", _wrap_Dwg_Header_Variables_ACADMAINTVER_get, METH_O, NULL},
	 { "Dwg_Header_Variables_REQUIREDVERSIONS_set", _wrap_Dwg_Header_Variables_REQUIREDVERSIONS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_REQUIREDVERSIONS_get", _wrap_Dwg_Header_Variables_REQUIREDVERSIONS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DWGCODEPAGE_set", _wrap_Dwg_Header_Variables_DWGCODEPAGE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DWGCODEPAGE_get", _wrap_Dwg_Header_Variables_DWGCODEPAGE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_codepage_set", _wrap_Dwg_Header_Variables_codepage_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_codepage_get", _wrap_Dwg_Header_Variables_codepage_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit1_ratio_set", _wrap_Dwg_Header_Variables_unit1_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit1_ratio_get", _wrap_Dwg_Header_Variables_unit1_ratio_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit2_ratio_set", _wrap_Dwg_Header_Variables_unit2_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit2_ratio_get", _wrap_Dwg_Header_Variables_unit2_ratio_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit3_ratio_set", _wrap_Dwg_Header_Variables_unit3_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit3_ratio_get", _wrap_Dwg_Header_Variables_unit3_ratio_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit4_ratio_set", _wrap_Dwg_Header_Variables_unit4_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit4_ratio_get", _wrap_Dwg_Header_Variables_unit4_ratio_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit1_name_set", _wrap_Dwg_Header_Variables_unit1_name_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit1_name_get", _wrap_Dwg_Header_Variables_unit1_name_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit2_name_set", _wrap_Dwg_Header_Variables_unit2_name_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit2_name_get", _wrap_Dwg_Header_Variables_unit2_name_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit3_name_set", _wrap_Dwg_Header_Variables_unit3_name_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit3_name_get", _wrap_Dwg_Header_Variables_unit3_name_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unit4_name_set", _wrap_Dwg_Header_Variables_unit4_name_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unit4_name_get", _wrap_Dwg_Header_Variables_unit4_name_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_8_set", _wrap_Dwg_Header_Variables_unknown_8_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_8_get", _wrap_Dwg_Header_Variables_unknown_8_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_9_set", _wrap_Dwg_Header_Variables_unknown_9_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_9_get", _wrap_Dwg_Header_Variables_unknown_9_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_10_set", _wrap_Dwg_Header_Variables_unknown_10_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_10_get", _wrap_Dwg_Header_Variables_unknown_10_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VX_TABLE_RECORD_set", _wrap_Dwg_Header_Variables_VX_TABLE_RECORD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VX_TABLE_RECORD_get", _wrap_Dwg_Header_Variables_VX_TABLE_RECORD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMASO_set", _wrap_Dwg_Header_Variables_DIMASO_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMASO_get", _wrap_Dwg_Header_Variables_DIMASO_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSHO_set", _wrap_Dwg_Header_Variables_DIMSHO_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSHO_get", _wrap_Dwg_Header_Variables_DIMSHO_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSAV_set", _wrap_Dwg_Header_Variables_DIMSAV_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSAV_get", _wrap_Dwg_Header_Variables_DIMSAV_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PLINEGEN_set", _wrap_Dwg_Header_Variables_PLINEGEN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PLINEGEN_get", _wrap_Dwg_Header_Variables_PLINEGEN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ORTHOMODE_set", _wrap_Dwg_Header_Variables_ORTHOMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ORTHOMODE_get", _wrap_Dwg_Header_Variables_ORTHOMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_REGENMODE_set", _wrap_Dwg_Header_Variables_REGENMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_REGENMODE_get", _wrap_Dwg_Header_Variables_REGENMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FILLMODE_set", _wrap_Dwg_Header_Variables_FILLMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FILLMODE_get", _wrap_Dwg_Header_Variables_FILLMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_QTEXTMODE_set", _wrap_Dwg_Header_Variables_QTEXTMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_QTEXTMODE_get", _wrap_Dwg_Header_Variables_QTEXTMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PSLTSCALE_set", _wrap_Dwg_Header_Variables_PSLTSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PSLTSCALE_get", _wrap_Dwg_Header_Variables_PSLTSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LIMCHECK_set", _wrap_Dwg_Header_Variables_LIMCHECK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LIMCHECK_get", _wrap_Dwg_Header_Variables_LIMCHECK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_MENUEXT_set", _wrap_Dwg_Header_Variables_MENUEXT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_MENUEXT_get", _wrap_Dwg_Header_Variables_MENUEXT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_BLIPMODE_set", _wrap_Dwg_Header_Variables_BLIPMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_BLIPMODE_get", _wrap_Dwg_Header_Variables_BLIPMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_11_set", _wrap_Dwg_Header_Variables_unknown_11_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_11_get", _wrap_Dwg_Header_Variables_unknown_11_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USRTIMER_set", _wrap_Dwg_Header_Variables_USRTIMER_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USRTIMER_get", _wrap_Dwg_Header_Variables_USRTIMER_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FASTZOOM_set", _wrap_Dwg_Header_Variables_FASTZOOM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FASTZOOM_get", _wrap_Dwg_Header_Variables_FASTZOOM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FLATLAND_set", _wrap_Dwg_Header_Variables_FLATLAND_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FLATLAND_get", _wrap_Dwg_Header_Variables_FLATLAND_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEWMODE_set", _wrap_Dwg_Header_Variables_VIEWMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEWMODE_get", _wrap_Dwg_Header_Variables_VIEWMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SKPOLY_set", _wrap_Dwg_Header_Variables_SKPOLY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SKPOLY_get", _wrap_Dwg_Header_Variables_SKPOLY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_mon_set", _wrap_Dwg_Header_Variables_unknown_mon_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_mon_get", _wrap_Dwg_Header_Variables_unknown_mon_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_day_set", _wrap_Dwg_Header_Variables_unknown_day_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_day_get", _wrap_Dwg_Header_Variables_unknown_day_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_year_set", _wrap_Dwg_Header_Variables_unknown_year_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_year_get", _wrap_Dwg_Header_Variables_unknown_year_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_hour_set", _wrap_Dwg_Header_Variables_unknown_hour_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_hour_get", _wrap_Dwg_Header_Variables_unknown_hour_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_min_set", _wrap_Dwg_Header_Variables_unknown_min_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_min_get", _wrap_Dwg_Header_Variables_unknown_min_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_sec_set", _wrap_Dwg_Header_Variables_unknown_sec_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_sec_get", _wrap_Dwg_Header_Variables_unknown_sec_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_ms_set", _wrap_Dwg_Header_Variables_unknown_ms_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_ms_get", _wrap_Dwg_Header_Variables_unknown_ms_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ANGDIR_set", _wrap_Dwg_Header_Variables_ANGDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ANGDIR_get", _wrap_Dwg_Header_Variables_ANGDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SPLFRAME_set", _wrap_Dwg_Header_Variables_SPLFRAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SPLFRAME_get", _wrap_Dwg_Header_Variables_SPLFRAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ATTREQ_set", _wrap_Dwg_Header_Variables_ATTREQ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ATTREQ_get", _wrap_Dwg_Header_Variables_ATTREQ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ATTDIA_set", _wrap_Dwg_Header_Variables_ATTDIA_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ATTDIA_get", _wrap_Dwg_Header_Variables_ATTDIA_get, METH_O, NULL},
	 { "Dwg_Header_Variables_MIRRTEXT_set", _wrap_Dwg_Header_Variables_MIRRTEXT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_MIRRTEXT_get", _wrap_Dwg_Header_Variables_MIRRTEXT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_WORLDVIEW_set", _wrap_Dwg_Header_Variables_WORLDVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_WORLDVIEW_get", _wrap_Dwg_Header_Variables_WORLDVIEW_get, METH_O, NULL},
	 { "Dwg_Header_Variables_WIREFRAME_set", _wrap_Dwg_Header_Variables_WIREFRAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_WIREFRAME_get", _wrap_Dwg_Header_Variables_WIREFRAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TILEMODE_set", _wrap_Dwg_Header_Variables_TILEMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TILEMODE_get", _wrap_Dwg_Header_Variables_TILEMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PLIMCHECK_set", _wrap_Dwg_Header_Variables_PLIMCHECK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PLIMCHECK_get", _wrap_Dwg_Header_Variables_PLIMCHECK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VISRETAIN_set", _wrap_Dwg_Header_Variables_VISRETAIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VISRETAIN_get", _wrap_Dwg_Header_Variables_VISRETAIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DELOBJ_set", _wrap_Dwg_Header_Variables_DELOBJ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DELOBJ_get", _wrap_Dwg_Header_Variables_DELOBJ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DISPSILH_set", _wrap_Dwg_Header_Variables_DISPSILH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DISPSILH_get", _wrap_Dwg_Header_Variables_DISPSILH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PELLIPSE_set", _wrap_Dwg_Header_Variables_PELLIPSE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PELLIPSE_get", _wrap_Dwg_Header_Variables_PELLIPSE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SAVEIMAGES_set", _wrap_Dwg_Header_Variables_SAVEIMAGES_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SAVEIMAGES_get", _wrap_Dwg_Header_Variables_SAVEIMAGES_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PROXYGRAPHICS_set", _wrap_Dwg_Header_Variables_PROXYGRAPHICS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PROXYGRAPHICS_get", _wrap_Dwg_Header_Variables_PROXYGRAPHICS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_MEASUREMENT_set", _wrap_Dwg_Header_Variables_MEASUREMENT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_MEASUREMENT_get", _wrap_Dwg_Header_Variables_MEASUREMENT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DRAGMODE_set", _wrap_Dwg_Header_Variables_DRAGMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DRAGMODE_get", _wrap_Dwg_Header_Variables_DRAGMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TREEDEPTH_set", _wrap_Dwg_Header_Variables_TREEDEPTH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TREEDEPTH_get", _wrap_Dwg_Header_Variables_TREEDEPTH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LUNITS_set", _wrap_Dwg_Header_Variables_LUNITS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LUNITS_get", _wrap_Dwg_Header_Variables_LUNITS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LUPREC_set", _wrap_Dwg_Header_Variables_LUPREC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LUPREC_get", _wrap_Dwg_Header_Variables_LUPREC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_AUNITS_set", _wrap_Dwg_Header_Variables_AUNITS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_AUNITS_get", _wrap_Dwg_Header_Variables_AUNITS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_AUPREC_set", _wrap_Dwg_Header_Variables_AUPREC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_AUPREC_get", _wrap_Dwg_Header_Variables_AUPREC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ATTMODE_set", _wrap_Dwg_Header_Variables_ATTMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ATTMODE_get", _wrap_Dwg_Header_Variables_ATTMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_COORDS_set", _wrap_Dwg_Header_Variables_COORDS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_COORDS_get", _wrap_Dwg_Header_Variables_COORDS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PDMODE_set", _wrap_Dwg_Header_Variables_PDMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PDMODE_get", _wrap_Dwg_Header_Variables_PDMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PICKSTYLE_set", _wrap_Dwg_Header_Variables_PICKSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PICKSTYLE_get", _wrap_Dwg_Header_Variables_PICKSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_OSMODE_set", _wrap_Dwg_Header_Variables_OSMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_OSMODE_get", _wrap_Dwg_Header_Variables_OSMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_12_set", _wrap_Dwg_Header_Variables_unknown_12_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_12_get", _wrap_Dwg_Header_Variables_unknown_12_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_13_set", _wrap_Dwg_Header_Variables_unknown_13_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_13_get", _wrap_Dwg_Header_Variables_unknown_13_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_14_set", _wrap_Dwg_Header_Variables_unknown_14_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_14_get", _wrap_Dwg_Header_Variables_unknown_14_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERI1_set", _wrap_Dwg_Header_Variables_USERI1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERI1_get", _wrap_Dwg_Header_Variables_USERI1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERI2_set", _wrap_Dwg_Header_Variables_USERI2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERI2_get", _wrap_Dwg_Header_Variables_USERI2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERI3_set", _wrap_Dwg_Header_Variables_USERI3_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERI3_get", _wrap_Dwg_Header_Variables_USERI3_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERI4_set", _wrap_Dwg_Header_Variables_USERI4_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERI4_get", _wrap_Dwg_Header_Variables_USERI4_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERI5_set", _wrap_Dwg_Header_Variables_USERI5_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERI5_get", _wrap_Dwg_Header_Variables_USERI5_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SPLINESEGS_set", _wrap_Dwg_Header_Variables_SPLINESEGS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SPLINESEGS_get", _wrap_Dwg_Header_Variables_SPLINESEGS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SURFU_set", _wrap_Dwg_Header_Variables_SURFU_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SURFU_get", _wrap_Dwg_Header_Variables_SURFU_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SURFV_set", _wrap_Dwg_Header_Variables_SURFV_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SURFV_get", _wrap_Dwg_Header_Variables_SURFV_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SURFTYPE_set", _wrap_Dwg_Header_Variables_SURFTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SURFTYPE_get", _wrap_Dwg_Header_Variables_SURFTYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SURFTAB1_set", _wrap_Dwg_Header_Variables_SURFTAB1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SURFTAB1_get", _wrap_Dwg_Header_Variables_SURFTAB1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SURFTAB2_set", _wrap_Dwg_Header_Variables_SURFTAB2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SURFTAB2_get", _wrap_Dwg_Header_Variables_SURFTAB2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SPLINETYPE_set", _wrap_Dwg_Header_Variables_SPLINETYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SPLINETYPE_get", _wrap_Dwg_Header_Variables_SPLINETYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SHADEDGE_set", _wrap_Dwg_Header_Variables_SHADEDGE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SHADEDGE_get", _wrap_Dwg_Header_Variables_SHADEDGE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SHADEDIF_set", _wrap_Dwg_Header_Variables_SHADEDIF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SHADEDIF_get", _wrap_Dwg_Header_Variables_SHADEDIF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UNITMODE_set", _wrap_Dwg_Header_Variables_UNITMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UNITMODE_get", _wrap_Dwg_Header_Variables_UNITMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_MAXACTVP_set", _wrap_Dwg_Header_Variables_MAXACTVP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_MAXACTVP_get", _wrap_Dwg_Header_Variables_MAXACTVP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ISOLINES_set", _wrap_Dwg_Header_Variables_ISOLINES_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ISOLINES_get", _wrap_Dwg_Header_Variables_ISOLINES_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CMLJUST_set", _wrap_Dwg_Header_Variables_CMLJUST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CMLJUST_get", _wrap_Dwg_Header_Variables_CMLJUST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TEXTQLTY_set", _wrap_Dwg_Header_Variables_TEXTQLTY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TEXTQLTY_get", _wrap_Dwg_Header_Variables_TEXTQLTY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_14b_set", _wrap_Dwg_Header_Variables_unknown_14b_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_14b_get", _wrap_Dwg_Header_Variables_unknown_14b_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LTSCALE_set", _wrap_Dwg_Header_Variables_LTSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LTSCALE_get", _wrap_Dwg_Header_Variables_LTSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TEXTSIZE_set", _wrap_Dwg_Header_Variables_TEXTSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TEXTSIZE_get", _wrap_Dwg_Header_Variables_TEXTSIZE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TRACEWID_set", _wrap_Dwg_Header_Variables_TRACEWID_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TRACEWID_get", _wrap_Dwg_Header_Variables_TRACEWID_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SKETCHINC_set", _wrap_Dwg_Header_Variables_SKETCHINC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SKETCHINC_get", _wrap_Dwg_Header_Variables_SKETCHINC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FILLETRAD_set", _wrap_Dwg_Header_Variables_FILLETRAD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FILLETRAD_get", _wrap_Dwg_Header_Variables_FILLETRAD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_THICKNESS_set", _wrap_Dwg_Header_Variables_THICKNESS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_THICKNESS_get", _wrap_Dwg_Header_Variables_THICKNESS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ANGBASE_set", _wrap_Dwg_Header_Variables_ANGBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ANGBASE_get", _wrap_Dwg_Header_Variables_ANGBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PDSIZE_set", _wrap_Dwg_Header_Variables_PDSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PDSIZE_get", _wrap_Dwg_Header_Variables_PDSIZE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PLINEWID_set", _wrap_Dwg_Header_Variables_PLINEWID_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PLINEWID_get", _wrap_Dwg_Header_Variables_PLINEWID_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERR1_set", _wrap_Dwg_Header_Variables_USERR1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERR1_get", _wrap_Dwg_Header_Variables_USERR1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERR2_set", _wrap_Dwg_Header_Variables_USERR2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERR2_get", _wrap_Dwg_Header_Variables_USERR2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERR3_set", _wrap_Dwg_Header_Variables_USERR3_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERR3_get", _wrap_Dwg_Header_Variables_USERR3_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERR4_set", _wrap_Dwg_Header_Variables_USERR4_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERR4_get", _wrap_Dwg_Header_Variables_USERR4_get, METH_O, NULL},
	 { "Dwg_Header_Variables_USERR5_set", _wrap_Dwg_Header_Variables_USERR5_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_USERR5_get", _wrap_Dwg_Header_Variables_USERR5_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CHAMFERA_set", _wrap_Dwg_Header_Variables_CHAMFERA_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CHAMFERA_get", _wrap_Dwg_Header_Variables_CHAMFERA_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CHAMFERB_set", _wrap_Dwg_Header_Variables_CHAMFERB_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CHAMFERB_get", _wrap_Dwg_Header_Variables_CHAMFERB_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CHAMFERC_set", _wrap_Dwg_Header_Variables_CHAMFERC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CHAMFERC_get", _wrap_Dwg_Header_Variables_CHAMFERC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CHAMFERD_set", _wrap_Dwg_Header_Variables_CHAMFERD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CHAMFERD_get", _wrap_Dwg_Header_Variables_CHAMFERD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FACETRES_set", _wrap_Dwg_Header_Variables_FACETRES_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FACETRES_get", _wrap_Dwg_Header_Variables_FACETRES_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CMLSCALE_set", _wrap_Dwg_Header_Variables_CMLSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CMLSCALE_get", _wrap_Dwg_Header_Variables_CMLSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CELTSCALE_set", _wrap_Dwg_Header_Variables_CELTSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CELTSCALE_get", _wrap_Dwg_Header_Variables_CELTSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEWTWIST_set", _wrap_Dwg_Header_Variables_VIEWTWIST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEWTWIST_get", _wrap_Dwg_Header_Variables_VIEWTWIST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_MENU_set", _wrap_Dwg_Header_Variables_MENU_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_MENU_get", _wrap_Dwg_Header_Variables_MENU_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDCREATE_set", _wrap_Dwg_Header_Variables_TDCREATE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDCREATE_get", _wrap_Dwg_Header_Variables_TDCREATE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDUPDATE_set", _wrap_Dwg_Header_Variables_TDUPDATE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDUPDATE_get", _wrap_Dwg_Header_Variables_TDUPDATE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDUCREATE_set", _wrap_Dwg_Header_Variables_TDUCREATE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDUCREATE_get", _wrap_Dwg_Header_Variables_TDUCREATE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDUUPDATE_set", _wrap_Dwg_Header_Variables_TDUUPDATE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDUUPDATE_get", _wrap_Dwg_Header_Variables_TDUUPDATE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_15_set", _wrap_Dwg_Header_Variables_unknown_15_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_15_get", _wrap_Dwg_Header_Variables_unknown_15_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_16_set", _wrap_Dwg_Header_Variables_unknown_16_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_16_get", _wrap_Dwg_Header_Variables_unknown_16_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_17_set", _wrap_Dwg_Header_Variables_unknown_17_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_17_get", _wrap_Dwg_Header_Variables_unknown_17_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDINDWG_set", _wrap_Dwg_Header_Variables_TDINDWG_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDINDWG_get", _wrap_Dwg_Header_Variables_TDINDWG_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TDUSRTIMER_set", _wrap_Dwg_Header_Variables_TDUSRTIMER_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TDUSRTIMER_get", _wrap_Dwg_Header_Variables_TDUSRTIMER_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CECOLOR_set", _wrap_Dwg_Header_Variables_CECOLOR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CECOLOR_get", _wrap_Dwg_Header_Variables_CECOLOR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_HANDLING_set", _wrap_Dwg_Header_Variables_HANDLING_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_HANDLING_get", _wrap_Dwg_Header_Variables_HANDLING_get, METH_O, NULL},
	 { "Dwg_Header_Variables_HANDSEED_set", _wrap_Dwg_Header_Variables_HANDSEED_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_HANDSEED_get", _wrap_Dwg_Header_Variables_HANDSEED_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_4f2_set", _wrap_Dwg_Header_Variables_unknown_4f2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_4f2_get", _wrap_Dwg_Header_Variables_unknown_4f2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_5_set", _wrap_Dwg_Header_Variables_unknown_5_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_5_get", _wrap_Dwg_Header_Variables_unknown_5_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_6_set", _wrap_Dwg_Header_Variables_unknown_6_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_6_get", _wrap_Dwg_Header_Variables_unknown_6_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_6a_set", _wrap_Dwg_Header_Variables_unknown_6a_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_6a_get", _wrap_Dwg_Header_Variables_unknown_6a_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_6b_set", _wrap_Dwg_Header_Variables_unknown_6b_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_6b_get", _wrap_Dwg_Header_Variables_unknown_6b_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_6c_set", _wrap_Dwg_Header_Variables_unknown_6c_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_6c_get", _wrap_Dwg_Header_Variables_unknown_6c_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CLAYER_set", _wrap_Dwg_Header_Variables_CLAYER_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CLAYER_get", _wrap_Dwg_Header_Variables_CLAYER_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TEXTSTYLE_set", _wrap_Dwg_Header_Variables_TEXTSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TEXTSTYLE_get", _wrap_Dwg_Header_Variables_TEXTSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CELTYPE_set", _wrap_Dwg_Header_Variables_CELTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CELTYPE_get", _wrap_Dwg_Header_Variables_CELTYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CMATERIAL_set", _wrap_Dwg_Header_Variables_CMATERIAL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CMATERIAL_get", _wrap_Dwg_Header_Variables_CMATERIAL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSTYLE_set", _wrap_Dwg_Header_Variables_DIMSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSTYLE_get", _wrap_Dwg_Header_Variables_DIMSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CMLSTYLE_set", _wrap_Dwg_Header_Variables_CMLSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CMLSTYLE_get", _wrap_Dwg_Header_Variables_CMLSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PSVPSCALE_set", _wrap_Dwg_Header_Variables_PSVPSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PSVPSCALE_get", _wrap_Dwg_Header_Variables_PSVPSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PINSBASE_set", _wrap_Dwg_Header_Variables_PINSBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PINSBASE_get", _wrap_Dwg_Header_Variables_PINSBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PEXTMIN_set", _wrap_Dwg_Header_Variables_PEXTMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PEXTMIN_get", _wrap_Dwg_Header_Variables_PEXTMIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PEXTMAX_set", _wrap_Dwg_Header_Variables_PEXTMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PEXTMAX_get", _wrap_Dwg_Header_Variables_PEXTMAX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PLIMMIN_set", _wrap_Dwg_Header_Variables_PLIMMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PLIMMIN_get", _wrap_Dwg_Header_Variables_PLIMMIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PLIMMAX_set", _wrap_Dwg_Header_Variables_PLIMMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PLIMMAX_get", _wrap_Dwg_Header_Variables_PLIMMAX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PELEVATION_set", _wrap_Dwg_Header_Variables_PELEVATION_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PELEVATION_get", _wrap_Dwg_Header_Variables_PELEVATION_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORG_set", _wrap_Dwg_Header_Variables_PUCSORG_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORG_get", _wrap_Dwg_Header_Variables_PUCSORG_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSXDIR_set", _wrap_Dwg_Header_Variables_PUCSXDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSXDIR_get", _wrap_Dwg_Header_Variables_PUCSXDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSYDIR_set", _wrap_Dwg_Header_Variables_PUCSYDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSYDIR_get", _wrap_Dwg_Header_Variables_PUCSYDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSNAME_set", _wrap_Dwg_Header_Variables_PUCSNAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSNAME_get", _wrap_Dwg_Header_Variables_PUCSNAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSBASE_set", _wrap_Dwg_Header_Variables_PUCSBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSBASE_get", _wrap_Dwg_Header_Variables_PUCSBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORTHOREF_set", _wrap_Dwg_Header_Variables_PUCSORTHOREF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORTHOREF_get", _wrap_Dwg_Header_Variables_PUCSORTHOREF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORTHOVIEW_set", _wrap_Dwg_Header_Variables_PUCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORTHOVIEW_get", _wrap_Dwg_Header_Variables_PUCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGTOP_set", _wrap_Dwg_Header_Variables_PUCSORGTOP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGTOP_get", _wrap_Dwg_Header_Variables_PUCSORGTOP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGBOTTOM_set", _wrap_Dwg_Header_Variables_PUCSORGBOTTOM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGBOTTOM_get", _wrap_Dwg_Header_Variables_PUCSORGBOTTOM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGLEFT_set", _wrap_Dwg_Header_Variables_PUCSORGLEFT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGLEFT_get", _wrap_Dwg_Header_Variables_PUCSORGLEFT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGRIGHT_set", _wrap_Dwg_Header_Variables_PUCSORGRIGHT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGRIGHT_get", _wrap_Dwg_Header_Variables_PUCSORGRIGHT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGFRONT_set", _wrap_Dwg_Header_Variables_PUCSORGFRONT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGFRONT_get", _wrap_Dwg_Header_Variables_PUCSORGFRONT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PUCSORGBACK_set", _wrap_Dwg_Header_Variables_PUCSORGBACK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PUCSORGBACK_get", _wrap_Dwg_Header_Variables_PUCSORGBACK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INSBASE_set", _wrap_Dwg_Header_Variables_INSBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INSBASE_get", _wrap_Dwg_Header_Variables_INSBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_EXTMIN_set", _wrap_Dwg_Header_Variables_EXTMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_EXTMIN_get", _wrap_Dwg_Header_Variables_EXTMIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_EXTMAX_set", _wrap_Dwg_Header_Variables_EXTMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_EXTMAX_get", _wrap_Dwg_Header_Variables_EXTMAX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEWDIR_set", _wrap_Dwg_Header_Variables_VIEWDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEWDIR_get", _wrap_Dwg_Header_Variables_VIEWDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TARGET_set", _wrap_Dwg_Header_Variables_TARGET_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TARGET_get", _wrap_Dwg_Header_Variables_TARGET_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LIMMIN_set", _wrap_Dwg_Header_Variables_LIMMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LIMMIN_get", _wrap_Dwg_Header_Variables_LIMMIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LIMMAX_set", _wrap_Dwg_Header_Variables_LIMMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LIMMAX_get", _wrap_Dwg_Header_Variables_LIMMAX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEWCTR_set", _wrap_Dwg_Header_Variables_VIEWCTR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEWCTR_get", _wrap_Dwg_Header_Variables_VIEWCTR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ELEVATION_set", _wrap_Dwg_Header_Variables_ELEVATION_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ELEVATION_get", _wrap_Dwg_Header_Variables_ELEVATION_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEWSIZE_set", _wrap_Dwg_Header_Variables_VIEWSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEWSIZE_get", _wrap_Dwg_Header_Variables_VIEWSIZE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPMODE_set", _wrap_Dwg_Header_Variables_SNAPMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPMODE_get", _wrap_Dwg_Header_Variables_SNAPMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPUNIT_set", _wrap_Dwg_Header_Variables_SNAPUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPUNIT_get", _wrap_Dwg_Header_Variables_SNAPUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPBASE_set", _wrap_Dwg_Header_Variables_SNAPBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPBASE_get", _wrap_Dwg_Header_Variables_SNAPBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPANG_set", _wrap_Dwg_Header_Variables_SNAPANG_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPANG_get", _wrap_Dwg_Header_Variables_SNAPANG_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPSTYLE_set", _wrap_Dwg_Header_Variables_SNAPSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPSTYLE_get", _wrap_Dwg_Header_Variables_SNAPSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SNAPISOPAIR_set", _wrap_Dwg_Header_Variables_SNAPISOPAIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SNAPISOPAIR_get", _wrap_Dwg_Header_Variables_SNAPISOPAIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_GRIDMODE_set", _wrap_Dwg_Header_Variables_GRIDMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_GRIDMODE_get", _wrap_Dwg_Header_Variables_GRIDMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_GRIDUNIT_set", _wrap_Dwg_Header_Variables_GRIDUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_GRIDUNIT_get", _wrap_Dwg_Header_Variables_GRIDUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_AXISMODE_set", _wrap_Dwg_Header_Variables_AXISMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_AXISMODE_get", _wrap_Dwg_Header_Variables_AXISMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_AXISUNIT_set", _wrap_Dwg_Header_Variables_AXISUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_AXISUNIT_get", _wrap_Dwg_Header_Variables_AXISUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTX_set", _wrap_Dwg_Header_Variables_VPOINTX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTX_get", _wrap_Dwg_Header_Variables_VPOINTX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTY_set", _wrap_Dwg_Header_Variables_VPOINTY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTY_get", _wrap_Dwg_Header_Variables_VPOINTY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTZ_set", _wrap_Dwg_Header_Variables_VPOINTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTZ_get", _wrap_Dwg_Header_Variables_VPOINTZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTXALT_set", _wrap_Dwg_Header_Variables_VPOINTXALT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTXALT_get", _wrap_Dwg_Header_Variables_VPOINTXALT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTYALT_set", _wrap_Dwg_Header_Variables_VPOINTYALT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTYALT_get", _wrap_Dwg_Header_Variables_VPOINTYALT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPOINTZALT_set", _wrap_Dwg_Header_Variables_VPOINTZALT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPOINTZALT_get", _wrap_Dwg_Header_Variables_VPOINTZALT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_flag_3d_set", _wrap_Dwg_Header_Variables_flag_3d_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_flag_3d_get", _wrap_Dwg_Header_Variables_flag_3d_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORG_set", _wrap_Dwg_Header_Variables_UCSORG_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORG_get", _wrap_Dwg_Header_Variables_UCSORG_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSXDIR_set", _wrap_Dwg_Header_Variables_UCSXDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSXDIR_get", _wrap_Dwg_Header_Variables_UCSXDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSYDIR_set", _wrap_Dwg_Header_Variables_UCSYDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSYDIR_get", _wrap_Dwg_Header_Variables_UCSYDIR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSNAME_set", _wrap_Dwg_Header_Variables_UCSNAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSNAME_get", _wrap_Dwg_Header_Variables_UCSNAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSBASE_set", _wrap_Dwg_Header_Variables_UCSBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSBASE_get", _wrap_Dwg_Header_Variables_UCSBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORTHOVIEW_set", _wrap_Dwg_Header_Variables_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORTHOVIEW_get", _wrap_Dwg_Header_Variables_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORTHOREF_set", _wrap_Dwg_Header_Variables_UCSORTHOREF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORTHOREF_get", _wrap_Dwg_Header_Variables_UCSORTHOREF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGTOP_set", _wrap_Dwg_Header_Variables_UCSORGTOP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGTOP_get", _wrap_Dwg_Header_Variables_UCSORGTOP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGBOTTOM_set", _wrap_Dwg_Header_Variables_UCSORGBOTTOM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGBOTTOM_get", _wrap_Dwg_Header_Variables_UCSORGBOTTOM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGLEFT_set", _wrap_Dwg_Header_Variables_UCSORGLEFT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGLEFT_get", _wrap_Dwg_Header_Variables_UCSORGLEFT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGRIGHT_set", _wrap_Dwg_Header_Variables_UCSORGRIGHT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGRIGHT_get", _wrap_Dwg_Header_Variables_UCSORGRIGHT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGFRONT_set", _wrap_Dwg_Header_Variables_UCSORGFRONT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGFRONT_get", _wrap_Dwg_Header_Variables_UCSORGFRONT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSORGBACK_set", _wrap_Dwg_Header_Variables_UCSORGBACK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSORGBACK_get", _wrap_Dwg_Header_Variables_UCSORGBACK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMPOST_set", _wrap_Dwg_Header_Variables_DIMPOST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMPOST_get", _wrap_Dwg_Header_Variables_DIMPOST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMAPOST_set", _wrap_Dwg_Header_Variables_DIMAPOST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMAPOST_get", _wrap_Dwg_Header_Variables_DIMAPOST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTOL_set", _wrap_Dwg_Header_Variables_DIMTOL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTOL_get", _wrap_Dwg_Header_Variables_DIMTOL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLIM_set", _wrap_Dwg_Header_Variables_DIMLIM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLIM_get", _wrap_Dwg_Header_Variables_DIMLIM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTIH_set", _wrap_Dwg_Header_Variables_DIMTIH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTIH_get", _wrap_Dwg_Header_Variables_DIMTIH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTOH_set", _wrap_Dwg_Header_Variables_DIMTOH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTOH_get", _wrap_Dwg_Header_Variables_DIMTOH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSE1_set", _wrap_Dwg_Header_Variables_DIMSE1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSE1_get", _wrap_Dwg_Header_Variables_DIMSE1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSE2_set", _wrap_Dwg_Header_Variables_DIMSE2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSE2_get", _wrap_Dwg_Header_Variables_DIMSE2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALT_set", _wrap_Dwg_Header_Variables_DIMALT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALT_get", _wrap_Dwg_Header_Variables_DIMALT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTOFL_set", _wrap_Dwg_Header_Variables_DIMTOFL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTOFL_get", _wrap_Dwg_Header_Variables_DIMTOFL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSAH_set", _wrap_Dwg_Header_Variables_DIMSAH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSAH_get", _wrap_Dwg_Header_Variables_DIMSAH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTIX_set", _wrap_Dwg_Header_Variables_DIMTIX_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTIX_get", _wrap_Dwg_Header_Variables_DIMTIX_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSOXD_set", _wrap_Dwg_Header_Variables_DIMSOXD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSOXD_get", _wrap_Dwg_Header_Variables_DIMSOXD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTD_set", _wrap_Dwg_Header_Variables_DIMALTD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTD_get", _wrap_Dwg_Header_Variables_DIMALTD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMZIN_set", _wrap_Dwg_Header_Variables_DIMZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMZIN_get", _wrap_Dwg_Header_Variables_DIMZIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSD1_set", _wrap_Dwg_Header_Variables_DIMSD1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSD1_get", _wrap_Dwg_Header_Variables_DIMSD1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSD2_set", _wrap_Dwg_Header_Variables_DIMSD2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSD2_get", _wrap_Dwg_Header_Variables_DIMSD2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTOLJ_set", _wrap_Dwg_Header_Variables_DIMTOLJ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTOLJ_get", _wrap_Dwg_Header_Variables_DIMTOLJ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMJUST_set", _wrap_Dwg_Header_Variables_DIMJUST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMJUST_get", _wrap_Dwg_Header_Variables_DIMJUST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMFIT_set", _wrap_Dwg_Header_Variables_DIMFIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMFIT_get", _wrap_Dwg_Header_Variables_DIMFIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMUPT_set", _wrap_Dwg_Header_Variables_DIMUPT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMUPT_get", _wrap_Dwg_Header_Variables_DIMUPT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTZIN_set", _wrap_Dwg_Header_Variables_DIMTZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTZIN_get", _wrap_Dwg_Header_Variables_DIMTZIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTAD_set", _wrap_Dwg_Header_Variables_DIMTAD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTAD_get", _wrap_Dwg_Header_Variables_DIMTAD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMUNIT_set", _wrap_Dwg_Header_Variables_DIMUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMUNIT_get", _wrap_Dwg_Header_Variables_DIMUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMAUNIT_set", _wrap_Dwg_Header_Variables_DIMAUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMAUNIT_get", _wrap_Dwg_Header_Variables_DIMAUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMDEC_set", _wrap_Dwg_Header_Variables_DIMDEC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMDEC_get", _wrap_Dwg_Header_Variables_DIMDEC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTDEC_set", _wrap_Dwg_Header_Variables_DIMTDEC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTDEC_get", _wrap_Dwg_Header_Variables_DIMTDEC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTU_set", _wrap_Dwg_Header_Variables_DIMALTU_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTU_get", _wrap_Dwg_Header_Variables_DIMALTU_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTTD_set", _wrap_Dwg_Header_Variables_DIMALTTD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTTD_get", _wrap_Dwg_Header_Variables_DIMALTTD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTXSTY_set", _wrap_Dwg_Header_Variables_DIMTXSTY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTXSTY_get", _wrap_Dwg_Header_Variables_DIMTXSTY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSCALE_set", _wrap_Dwg_Header_Variables_DIMSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSCALE_get", _wrap_Dwg_Header_Variables_DIMSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMARROW_set", _wrap_Dwg_Header_Variables_DIMARROW_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMARROW_get", _wrap_Dwg_Header_Variables_DIMARROW_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMASZ_set", _wrap_Dwg_Header_Variables_DIMASZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMASZ_get", _wrap_Dwg_Header_Variables_DIMASZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMEXO_set", _wrap_Dwg_Header_Variables_DIMEXO_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMEXO_get", _wrap_Dwg_Header_Variables_DIMEXO_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMDLI_set", _wrap_Dwg_Header_Variables_DIMDLI_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMDLI_get", _wrap_Dwg_Header_Variables_DIMDLI_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMEXE_set", _wrap_Dwg_Header_Variables_DIMEXE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMEXE_get", _wrap_Dwg_Header_Variables_DIMEXE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMRND_set", _wrap_Dwg_Header_Variables_DIMRND_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMRND_get", _wrap_Dwg_Header_Variables_DIMRND_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMDLE_set", _wrap_Dwg_Header_Variables_DIMDLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMDLE_get", _wrap_Dwg_Header_Variables_DIMDLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTP_set", _wrap_Dwg_Header_Variables_DIMTP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTP_get", _wrap_Dwg_Header_Variables_DIMTP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTM_set", _wrap_Dwg_Header_Variables_DIMTM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTM_get", _wrap_Dwg_Header_Variables_DIMTM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMFXL_set", _wrap_Dwg_Header_Variables_DIMFXL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMFXL_get", _wrap_Dwg_Header_Variables_DIMFXL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMJOGANG_set", _wrap_Dwg_Header_Variables_DIMJOGANG_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMJOGANG_get", _wrap_Dwg_Header_Variables_DIMJOGANG_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTFILL_set", _wrap_Dwg_Header_Variables_DIMTFILL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTFILL_get", _wrap_Dwg_Header_Variables_DIMTFILL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTFILLCLR_set", _wrap_Dwg_Header_Variables_DIMTFILLCLR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTFILLCLR_get", _wrap_Dwg_Header_Variables_DIMTFILLCLR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMAZIN_set", _wrap_Dwg_Header_Variables_DIMAZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMAZIN_get", _wrap_Dwg_Header_Variables_DIMAZIN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMARCSYM_set", _wrap_Dwg_Header_Variables_DIMARCSYM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMARCSYM_get", _wrap_Dwg_Header_Variables_DIMARCSYM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTXT_set", _wrap_Dwg_Header_Variables_DIMTXT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTXT_get", _wrap_Dwg_Header_Variables_DIMTXT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCEN_set", _wrap_Dwg_Header_Variables_DIMCEN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCEN_get", _wrap_Dwg_Header_Variables_DIMCEN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTSZ_set", _wrap_Dwg_Header_Variables_DIMTSZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTSZ_get", _wrap_Dwg_Header_Variables_DIMTSZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTF_set", _wrap_Dwg_Header_Variables_DIMALTF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTF_get", _wrap_Dwg_Header_Variables_DIMALTF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLFAC_set", _wrap_Dwg_Header_Variables_DIMLFAC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLFAC_get", _wrap_Dwg_Header_Variables_DIMLFAC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTVP_set", _wrap_Dwg_Header_Variables_DIMTVP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTVP_get", _wrap_Dwg_Header_Variables_DIMTVP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTFAC_set", _wrap_Dwg_Header_Variables_DIMTFAC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTFAC_get", _wrap_Dwg_Header_Variables_DIMTFAC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMGAP_set", _wrap_Dwg_Header_Variables_DIMGAP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMGAP_get", _wrap_Dwg_Header_Variables_DIMGAP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMPOST_T_set", _wrap_Dwg_Header_Variables_DIMPOST_T_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMPOST_T_get", _wrap_Dwg_Header_Variables_DIMPOST_T_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMAPOST_T_set", _wrap_Dwg_Header_Variables_DIMAPOST_T_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMAPOST_T_get", _wrap_Dwg_Header_Variables_DIMAPOST_T_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK_T_set", _wrap_Dwg_Header_Variables_DIMBLK_T_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK_T_get", _wrap_Dwg_Header_Variables_DIMBLK_T_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK1_T_set", _wrap_Dwg_Header_Variables_DIMBLK1_T_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK1_T_get", _wrap_Dwg_Header_Variables_DIMBLK1_T_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK2_T_set", _wrap_Dwg_Header_Variables_DIMBLK2_T_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK2_T_get", _wrap_Dwg_Header_Variables_DIMBLK2_T_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_string_set", _wrap_Dwg_Header_Variables_unknown_string_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_string_get", _wrap_Dwg_Header_Variables_unknown_string_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTRND_set", _wrap_Dwg_Header_Variables_DIMALTRND_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTRND_get", _wrap_Dwg_Header_Variables_DIMALTRND_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRD_C_set", _wrap_Dwg_Header_Variables_DIMCLRD_C_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRD_C_get", _wrap_Dwg_Header_Variables_DIMCLRD_C_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRE_C_set", _wrap_Dwg_Header_Variables_DIMCLRE_C_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRE_C_get", _wrap_Dwg_Header_Variables_DIMCLRE_C_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRT_C_set", _wrap_Dwg_Header_Variables_DIMCLRT_C_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRT_C_get", _wrap_Dwg_Header_Variables_DIMCLRT_C_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRD_set", _wrap_Dwg_Header_Variables_DIMCLRD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRD_get", _wrap_Dwg_Header_Variables_DIMCLRD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRE_set", _wrap_Dwg_Header_Variables_DIMCLRE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRE_get", _wrap_Dwg_Header_Variables_DIMCLRE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMCLRT_set", _wrap_Dwg_Header_Variables_DIMCLRT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMCLRT_get", _wrap_Dwg_Header_Variables_DIMCLRT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMADEC_set", _wrap_Dwg_Header_Variables_DIMADEC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMADEC_get", _wrap_Dwg_Header_Variables_DIMADEC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMFRAC_set", _wrap_Dwg_Header_Variables_DIMFRAC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMFRAC_get", _wrap_Dwg_Header_Variables_DIMFRAC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLUNIT_set", _wrap_Dwg_Header_Variables_DIMLUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLUNIT_get", _wrap_Dwg_Header_Variables_DIMLUNIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMDSEP_set", _wrap_Dwg_Header_Variables_DIMDSEP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMDSEP_get", _wrap_Dwg_Header_Variables_DIMDSEP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTMOVE_set", _wrap_Dwg_Header_Variables_DIMTMOVE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTMOVE_get", _wrap_Dwg_Header_Variables_DIMTMOVE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTZ_set", _wrap_Dwg_Header_Variables_DIMALTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTZ_get", _wrap_Dwg_Header_Variables_DIMALTZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTTZ_set", _wrap_Dwg_Header_Variables_DIMALTTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTTZ_get", _wrap_Dwg_Header_Variables_DIMALTTZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMATFIT_set", _wrap_Dwg_Header_Variables_DIMATFIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMATFIT_get", _wrap_Dwg_Header_Variables_DIMATFIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMFXLON_set", _wrap_Dwg_Header_Variables_DIMFXLON_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMFXLON_get", _wrap_Dwg_Header_Variables_DIMFXLON_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMTXTDIRECTION_set", _wrap_Dwg_Header_Variables_DIMTXTDIRECTION_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMTXTDIRECTION_get", _wrap_Dwg_Header_Variables_DIMTXTDIRECTION_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTMZF_set", _wrap_Dwg_Header_Variables_DIMALTMZF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTMZF_get", _wrap_Dwg_Header_Variables_DIMALTMZF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMALTMZS_set", _wrap_Dwg_Header_Variables_DIMALTMZS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMALTMZS_get", _wrap_Dwg_Header_Variables_DIMALTMZS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMMZF_set", _wrap_Dwg_Header_Variables_DIMMZF_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMMZF_get", _wrap_Dwg_Header_Variables_DIMMZF_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMMZS_set", _wrap_Dwg_Header_Variables_DIMMZS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMMZS_get", _wrap_Dwg_Header_Variables_DIMMZS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLDRBLK_set", _wrap_Dwg_Header_Variables_DIMLDRBLK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLDRBLK_get", _wrap_Dwg_Header_Variables_DIMLDRBLK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK_set", _wrap_Dwg_Header_Variables_DIMBLK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK_get", _wrap_Dwg_Header_Variables_DIMBLK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK1_set", _wrap_Dwg_Header_Variables_DIMBLK1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK1_get", _wrap_Dwg_Header_Variables_DIMBLK1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMBLK2_set", _wrap_Dwg_Header_Variables_DIMBLK2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMBLK2_get", _wrap_Dwg_Header_Variables_DIMBLK2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLTYPE_set", _wrap_Dwg_Header_Variables_DIMLTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLTYPE_get", _wrap_Dwg_Header_Variables_DIMLTYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLTEX1_set", _wrap_Dwg_Header_Variables_DIMLTEX1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLTEX1_get", _wrap_Dwg_Header_Variables_DIMLTEX1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLTEX2_set", _wrap_Dwg_Header_Variables_DIMLTEX2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLTEX2_get", _wrap_Dwg_Header_Variables_DIMLTEX2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLWD_set", _wrap_Dwg_Header_Variables_DIMLWD_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLWD_get", _wrap_Dwg_Header_Variables_DIMLWD_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMLWE_set", _wrap_Dwg_Header_Variables_DIMLWE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMLWE_get", _wrap_Dwg_Header_Variables_DIMLWE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_BLOCK_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_LAYER_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LAYER_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_LAYER_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_STYLE_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_STYLE_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_STYLE_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_LTYPE_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_VIEW_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VIEW_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_VIEW_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCS_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_UCS_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCS_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_UCS_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_VPORT_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VPORT_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_VPORT_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_APPID_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_APPID_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_APPID_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_APPID_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_DIMSTYLE_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VX_CONTROL_OBJECT_set", _wrap_Dwg_Header_Variables_VX_CONTROL_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VX_CONTROL_OBJECT_get", _wrap_Dwg_Header_Variables_VX_CONTROL_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set", _wrap_Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_get", _wrap_Dwg_Header_Variables_DICTIONARY_ACAD_GROUP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set", _wrap_Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_get", _wrap_Dwg_Header_Variables_DICTIONARY_ACAD_MLINESTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set", _wrap_Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_get", _wrap_Dwg_Header_Variables_DICTIONARY_NAMED_OBJECT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TSTACKALIGN_set", _wrap_Dwg_Header_Variables_TSTACKALIGN_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TSTACKALIGN_get", _wrap_Dwg_Header_Variables_TSTACKALIGN_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TSTACKSIZE_set", _wrap_Dwg_Header_Variables_TSTACKSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TSTACKSIZE_get", _wrap_Dwg_Header_Variables_TSTACKSIZE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_HYPERLINKBASE_set", _wrap_Dwg_Header_Variables_HYPERLINKBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_HYPERLINKBASE_get", _wrap_Dwg_Header_Variables_HYPERLINKBASE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_STYLESHEET_set", _wrap_Dwg_Header_Variables_STYLESHEET_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_STYLESHEET_get", _wrap_Dwg_Header_Variables_STYLESHEET_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_LAYOUT_set", _wrap_Dwg_Header_Variables_DICTIONARY_LAYOUT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_LAYOUT_get", _wrap_Dwg_Header_Variables_DICTIONARY_LAYOUT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set", _wrap_Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_get", _wrap_Dwg_Header_Variables_DICTIONARY_PLOTSETTINGS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set", _wrap_Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_get", _wrap_Dwg_Header_Variables_DICTIONARY_PLOTSTYLENAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_MATERIAL_set", _wrap_Dwg_Header_Variables_DICTIONARY_MATERIAL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_MATERIAL_get", _wrap_Dwg_Header_Variables_DICTIONARY_MATERIAL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_COLOR_set", _wrap_Dwg_Header_Variables_DICTIONARY_COLOR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_COLOR_get", _wrap_Dwg_Header_Variables_DICTIONARY_COLOR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set", _wrap_Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_get", _wrap_Dwg_Header_Variables_DICTIONARY_VISUALSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set", _wrap_Dwg_Header_Variables_DICTIONARY_LIGHTLIST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DICTIONARY_LIGHTLIST_get", _wrap_Dwg_Header_Variables_DICTIONARY_LIGHTLIST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_20_set", _wrap_Dwg_Header_Variables_unknown_20_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_20_get", _wrap_Dwg_Header_Variables_unknown_20_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FLAGS_set", _wrap_Dwg_Header_Variables_FLAGS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FLAGS_get", _wrap_Dwg_Header_Variables_FLAGS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CELWEIGHT_set", _wrap_Dwg_Header_Variables_CELWEIGHT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CELWEIGHT_get", _wrap_Dwg_Header_Variables_CELWEIGHT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_ENDCAPS_set", _wrap_Dwg_Header_Variables_ENDCAPS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_ENDCAPS_get", _wrap_Dwg_Header_Variables_ENDCAPS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_JOINSTYLE_set", _wrap_Dwg_Header_Variables_JOINSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_JOINSTYLE_get", _wrap_Dwg_Header_Variables_JOINSTYLE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LWDISPLAY_set", _wrap_Dwg_Header_Variables_LWDISPLAY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LWDISPLAY_get", _wrap_Dwg_Header_Variables_LWDISPLAY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_XEDIT_set", _wrap_Dwg_Header_Variables_XEDIT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_XEDIT_get", _wrap_Dwg_Header_Variables_XEDIT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_EXTNAMES_set", _wrap_Dwg_Header_Variables_EXTNAMES_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_EXTNAMES_get", _wrap_Dwg_Header_Variables_EXTNAMES_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PSTYLEMODE_set", _wrap_Dwg_Header_Variables_PSTYLEMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PSTYLEMODE_get", _wrap_Dwg_Header_Variables_PSTYLEMODE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_OLESTARTUP_set", _wrap_Dwg_Header_Variables_OLESTARTUP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_OLESTARTUP_get", _wrap_Dwg_Header_Variables_OLESTARTUP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INSUNITS_set", _wrap_Dwg_Header_Variables_INSUNITS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INSUNITS_get", _wrap_Dwg_Header_Variables_INSUNITS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CEPSNTYPE_set", _wrap_Dwg_Header_Variables_CEPSNTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CEPSNTYPE_get", _wrap_Dwg_Header_Variables_CEPSNTYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CPSNID_set", _wrap_Dwg_Header_Variables_CPSNID_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CPSNID_get", _wrap_Dwg_Header_Variables_CPSNID_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FINGERPRINTGUID_set", _wrap_Dwg_Header_Variables_FINGERPRINTGUID_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FINGERPRINTGUID_get", _wrap_Dwg_Header_Variables_FINGERPRINTGUID_get, METH_O, NULL},
	 { "Dwg_Header_Variables_VERSIONGUID_set", _wrap_Dwg_Header_Variables_VERSIONGUID_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_VERSIONGUID_get", _wrap_Dwg_Header_Variables_VERSIONGUID_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SORTENTS_set", _wrap_Dwg_Header_Variables_SORTENTS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SORTENTS_get", _wrap_Dwg_Header_Variables_SORTENTS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INDEXCTL_set", _wrap_Dwg_Header_Variables_INDEXCTL_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INDEXCTL_get", _wrap_Dwg_Header_Variables_INDEXCTL_get, METH_O, NULL},
	 { "Dwg_Header_Variables_HIDETEXT_set", _wrap_Dwg_Header_Variables_HIDETEXT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_HIDETEXT_get", _wrap_Dwg_Header_Variables_HIDETEXT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_XCLIPFRAME_set", _wrap_Dwg_Header_Variables_XCLIPFRAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_XCLIPFRAME_get", _wrap_Dwg_Header_Variables_XCLIPFRAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DIMASSOC_set", _wrap_Dwg_Header_Variables_DIMASSOC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DIMASSOC_get", _wrap_Dwg_Header_Variables_DIMASSOC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_HALOGAP_set", _wrap_Dwg_Header_Variables_HALOGAP_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_HALOGAP_get", _wrap_Dwg_Header_Variables_HALOGAP_get, METH_O, NULL},
	 { "Dwg_Header_Variables_OBSCOLOR_set", _wrap_Dwg_Header_Variables_OBSCOLOR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_OBSCOLOR_get", _wrap_Dwg_Header_Variables_OBSCOLOR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INTERSECTIONCOLOR_set", _wrap_Dwg_Header_Variables_INTERSECTIONCOLOR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INTERSECTIONCOLOR_get", _wrap_Dwg_Header_Variables_INTERSECTIONCOLOR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_OBSLTYPE_set", _wrap_Dwg_Header_Variables_OBSLTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_OBSLTYPE_get", _wrap_Dwg_Header_Variables_OBSLTYPE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INTERSECTIONDISPLAY_set", _wrap_Dwg_Header_Variables_INTERSECTIONDISPLAY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INTERSECTIONDISPLAY_get", _wrap_Dwg_Header_Variables_INTERSECTIONDISPLAY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PROJECTNAME_set", _wrap_Dwg_Header_Variables_PROJECTNAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PROJECTNAME_get", _wrap_Dwg_Header_Variables_PROJECTNAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set", _wrap_Dwg_Header_Variables_BLOCK_RECORD_PSPACE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_BLOCK_RECORD_PSPACE_get", _wrap_Dwg_Header_Variables_BLOCK_RECORD_PSPACE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set", _wrap_Dwg_Header_Variables_BLOCK_RECORD_MSPACE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_BLOCK_RECORD_MSPACE_get", _wrap_Dwg_Header_Variables_BLOCK_RECORD_MSPACE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LTYPE_BYLAYER_set", _wrap_Dwg_Header_Variables_LTYPE_BYLAYER_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LTYPE_BYLAYER_get", _wrap_Dwg_Header_Variables_LTYPE_BYLAYER_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LTYPE_BYBLOCK_set", _wrap_Dwg_Header_Variables_LTYPE_BYBLOCK_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LTYPE_BYBLOCK_get", _wrap_Dwg_Header_Variables_LTYPE_BYBLOCK_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LTYPE_CONTINUOUS_set", _wrap_Dwg_Header_Variables_LTYPE_CONTINUOUS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LTYPE_CONTINUOUS_get", _wrap_Dwg_Header_Variables_LTYPE_CONTINUOUS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CAMERADISPLAY_set", _wrap_Dwg_Header_Variables_CAMERADISPLAY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CAMERADISPLAY_get", _wrap_Dwg_Header_Variables_CAMERADISPLAY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_21_set", _wrap_Dwg_Header_Variables_unknown_21_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_21_get", _wrap_Dwg_Header_Variables_unknown_21_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_22_set", _wrap_Dwg_Header_Variables_unknown_22_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_22_get", _wrap_Dwg_Header_Variables_unknown_22_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_23_set", _wrap_Dwg_Header_Variables_unknown_23_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_23_get", _wrap_Dwg_Header_Variables_unknown_23_get, METH_O, NULL},
	 { "Dwg_Header_Variables_STEPSPERSEC_set", _wrap_Dwg_Header_Variables_STEPSPERSEC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_STEPSPERSEC_get", _wrap_Dwg_Header_Variables_STEPSPERSEC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_STEPSIZE_set", _wrap_Dwg_Header_Variables_STEPSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_STEPSIZE_get", _wrap_Dwg_Header_Variables_STEPSIZE_get, METH_O, NULL},
	 { "Dwg_Header_Variables__3DDWFPREC_set", _wrap_Dwg_Header_Variables__3DDWFPREC_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables__3DDWFPREC_get", _wrap_Dwg_Header_Variables__3DDWFPREC_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LENSLENGTH_set", _wrap_Dwg_Header_Variables_LENSLENGTH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LENSLENGTH_get", _wrap_Dwg_Header_Variables_LENSLENGTH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CAMERAHEIGHT_set", _wrap_Dwg_Header_Variables_CAMERAHEIGHT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CAMERAHEIGHT_get", _wrap_Dwg_Header_Variables_CAMERAHEIGHT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SOLIDHIST_set", _wrap_Dwg_Header_Variables_SOLIDHIST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SOLIDHIST_get", _wrap_Dwg_Header_Variables_SOLIDHIST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SHOWHIST_set", _wrap_Dwg_Header_Variables_SHOWHIST_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SHOWHIST_get", _wrap_Dwg_Header_Variables_SHOWHIST_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PSOLWIDTH_set", _wrap_Dwg_Header_Variables_PSOLWIDTH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PSOLWIDTH_get", _wrap_Dwg_Header_Variables_PSOLWIDTH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_PSOLHEIGHT_set", _wrap_Dwg_Header_Variables_PSOLHEIGHT_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_PSOLHEIGHT_get", _wrap_Dwg_Header_Variables_PSOLHEIGHT_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTANG1_set", _wrap_Dwg_Header_Variables_LOFTANG1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTANG1_get", _wrap_Dwg_Header_Variables_LOFTANG1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTANG2_set", _wrap_Dwg_Header_Variables_LOFTANG2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTANG2_get", _wrap_Dwg_Header_Variables_LOFTANG2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTMAG1_set", _wrap_Dwg_Header_Variables_LOFTMAG1_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTMAG1_get", _wrap_Dwg_Header_Variables_LOFTMAG1_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTMAG2_set", _wrap_Dwg_Header_Variables_LOFTMAG2_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTMAG2_get", _wrap_Dwg_Header_Variables_LOFTMAG2_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTPARAM_set", _wrap_Dwg_Header_Variables_LOFTPARAM_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTPARAM_get", _wrap_Dwg_Header_Variables_LOFTPARAM_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LOFTNORMALS_set", _wrap_Dwg_Header_Variables_LOFTNORMALS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LOFTNORMALS_get", _wrap_Dwg_Header_Variables_LOFTNORMALS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LATITUDE_set", _wrap_Dwg_Header_Variables_LATITUDE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LATITUDE_get", _wrap_Dwg_Header_Variables_LATITUDE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LONGITUDE_set", _wrap_Dwg_Header_Variables_LONGITUDE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LONGITUDE_get", _wrap_Dwg_Header_Variables_LONGITUDE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_NORTHDIRECTION_set", _wrap_Dwg_Header_Variables_NORTHDIRECTION_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_NORTHDIRECTION_get", _wrap_Dwg_Header_Variables_NORTHDIRECTION_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TIMEZONE_set", _wrap_Dwg_Header_Variables_TIMEZONE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TIMEZONE_get", _wrap_Dwg_Header_Variables_TIMEZONE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set", _wrap_Dwg_Header_Variables_LIGHTGLYPHDISPLAY_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_LIGHTGLYPHDISPLAY_get", _wrap_Dwg_Header_Variables_LIGHTGLYPHDISPLAY_get, METH_O, NULL},
	 { "Dwg_Header_Variables_TILEMODELIGHTSYNCH_set", _wrap_Dwg_Header_Variables_TILEMODELIGHTSYNCH_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_TILEMODELIGHTSYNCH_get", _wrap_Dwg_Header_Variables_TILEMODELIGHTSYNCH_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DWFFRAME_set", _wrap_Dwg_Header_Variables_DWFFRAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DWFFRAME_get", _wrap_Dwg_Header_Variables_DWFFRAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DGNFRAME_set", _wrap_Dwg_Header_Variables_DGNFRAME_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DGNFRAME_get", _wrap_Dwg_Header_Variables_DGNFRAME_get, METH_O, NULL},
	 { "Dwg_Header_Variables_REALWORLDSCALE_set", _wrap_Dwg_Header_Variables_REALWORLDSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_REALWORLDSCALE_get", _wrap_Dwg_Header_Variables_REALWORLDSCALE_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INTERFERECOLOR_set", _wrap_Dwg_Header_Variables_INTERFERECOLOR_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INTERFERECOLOR_get", _wrap_Dwg_Header_Variables_INTERFERECOLOR_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INTERFEREOBJVS_set", _wrap_Dwg_Header_Variables_INTERFEREOBJVS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INTERFEREOBJVS_get", _wrap_Dwg_Header_Variables_INTERFEREOBJVS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_INTERFEREVPVS_set", _wrap_Dwg_Header_Variables_INTERFEREVPVS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_INTERFEREVPVS_get", _wrap_Dwg_Header_Variables_INTERFEREVPVS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_DRAGVS_set", _wrap_Dwg_Header_Variables_DRAGVS_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_DRAGVS_get", _wrap_Dwg_Header_Variables_DRAGVS_get, METH_O, NULL},
	 { "Dwg_Header_Variables_CSHADOW_set", _wrap_Dwg_Header_Variables_CSHADOW_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_CSHADOW_get", _wrap_Dwg_Header_Variables_CSHADOW_get, METH_O, NULL},
	 { "Dwg_Header_Variables_SHADOWPLANELOCATION_set", _wrap_Dwg_Header_Variables_SHADOWPLANELOCATION_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_SHADOWPLANELOCATION_get", _wrap_Dwg_Header_Variables_SHADOWPLANELOCATION_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_54_set", _wrap_Dwg_Header_Variables_unknown_54_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_54_get", _wrap_Dwg_Header_Variables_unknown_54_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_55_set", _wrap_Dwg_Header_Variables_unknown_55_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_55_get", _wrap_Dwg_Header_Variables_unknown_55_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_56_set", _wrap_Dwg_Header_Variables_unknown_56_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_56_get", _wrap_Dwg_Header_Variables_unknown_56_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_57_set", _wrap_Dwg_Header_Variables_unknown_57_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_57_get", _wrap_Dwg_Header_Variables_unknown_57_get, METH_O, NULL},
	 { "Dwg_Header_Variables_dwg_size_set", _wrap_Dwg_Header_Variables_dwg_size_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_dwg_size_get", _wrap_Dwg_Header_Variables_dwg_size_get, METH_O, NULL},
	 { "Dwg_Header_Variables_numentities_set", _wrap_Dwg_Header_Variables_numentities_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_numentities_get", _wrap_Dwg_Header_Variables_numentities_get, METH_O, NULL},
	 { "Dwg_Header_Variables_circle_zoom_percent_set", _wrap_Dwg_Header_Variables_circle_zoom_percent_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_circle_zoom_percent_get", _wrap_Dwg_Header_Variables_circle_zoom_percent_get, METH_O, NULL},
	 { "Dwg_Header_Variables_FRONTZ_set", _wrap_Dwg_Header_Variables_FRONTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_FRONTZ_get", _wrap_Dwg_Header_Variables_FRONTZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_BACKZ_set", _wrap_Dwg_Header_Variables_BACKZ_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_BACKZ_get", _wrap_Dwg_Header_Variables_BACKZ_get, METH_O, NULL},
	 { "Dwg_Header_Variables_UCSICON_set", _wrap_Dwg_Header_Variables_UCSICON_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_UCSICON_get", _wrap_Dwg_Header_Variables_UCSICON_get, METH_O, NULL},
	 { "Dwg_Header_Variables_oldCECOLOR_hi_set", _wrap_Dwg_Header_Variables_oldCECOLOR_hi_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_oldCECOLOR_hi_get", _wrap_Dwg_Header_Variables_oldCECOLOR_hi_get, METH_O, NULL},
	 { "Dwg_Header_Variables_oldCECOLOR_lo_set", _wrap_Dwg_Header_Variables_oldCECOLOR_lo_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_oldCECOLOR_lo_get", _wrap_Dwg_Header_Variables_oldCECOLOR_lo_get, METH_O, NULL},
	 { "Dwg_Header_Variables_layer_colors_set", _wrap_Dwg_Header_Variables_layer_colors_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_layer_colors_get", _wrap_Dwg_Header_Variables_layer_colors_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_51e_set", _wrap_Dwg_Header_Variables_unknown_51e_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_51e_get", _wrap_Dwg_Header_Variables_unknown_51e_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_520_set", _wrap_Dwg_Header_Variables_unknown_520_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_520_get", _wrap_Dwg_Header_Variables_unknown_520_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_52c_set", _wrap_Dwg_Header_Variables_unknown_52c_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_52c_get", _wrap_Dwg_Header_Variables_unknown_52c_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_52e_set", _wrap_Dwg_Header_Variables_unknown_52e_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_52e_get", _wrap_Dwg_Header_Variables_unknown_52e_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_530_set", _wrap_Dwg_Header_Variables_unknown_530_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_530_get", _wrap_Dwg_Header_Variables_unknown_530_get, METH_O, NULL},
	 { "Dwg_Header_Variables_unknown_59_set", _wrap_Dwg_Header_Variables_unknown_59_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_unknown_59_get", _wrap_Dwg_Header_Variables_unknown_59_get, METH_O, NULL},
	 { "Dwg_Header_Variables_aspect_ratio_set", _wrap_Dwg_Header_Variables_aspect_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Header_Variables_aspect_ratio_get", _wrap_Dwg_Header_Variables_aspect_ratio_get, METH_O, NULL},
	 { "new_Dwg_Header_Variables", _wrap_new_Dwg_Header_Variables, METH_NOARGS, NULL},
	 { "delete_Dwg_Header_Variables", _wrap_delete_Dwg_Header_Variables, METH_O, NULL},
	 { "Dwg_Header_Variables_swigregister", Dwg_Header_Variables_swigregister, METH_O, NULL},
	 { "Dwg_Header_Variables_swiginit", Dwg_Header_Variables_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_parent_set", _wrap_Dwg_Entity_TEXT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_parent_get", _wrap_Dwg_Entity_TEXT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_dataflags_set", _wrap_Dwg_Entity_TEXT_dataflags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_dataflags_get", _wrap_Dwg_Entity_TEXT_dataflags_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_elevation_set", _wrap_Dwg_Entity_TEXT_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_elevation_get", _wrap_Dwg_Entity_TEXT_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_ins_pt_set", _wrap_Dwg_Entity_TEXT_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_ins_pt_get", _wrap_Dwg_Entity_TEXT_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_alignment_pt_set", _wrap_Dwg_Entity_TEXT_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_alignment_pt_get", _wrap_Dwg_Entity_TEXT_alignment_pt_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_extrusion_set", _wrap_Dwg_Entity_TEXT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_extrusion_get", _wrap_Dwg_Entity_TEXT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_thickness_set", _wrap_Dwg_Entity_TEXT_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_thickness_get", _wrap_Dwg_Entity_TEXT_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_oblique_angle_set", _wrap_Dwg_Entity_TEXT_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_oblique_angle_get", _wrap_Dwg_Entity_TEXT_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_rotation_set", _wrap_Dwg_Entity_TEXT_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_rotation_get", _wrap_Dwg_Entity_TEXT_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_height_set", _wrap_Dwg_Entity_TEXT_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_height_get", _wrap_Dwg_Entity_TEXT_height_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_width_factor_set", _wrap_Dwg_Entity_TEXT_width_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_width_factor_get", _wrap_Dwg_Entity_TEXT_width_factor_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_text_value_set", _wrap_Dwg_Entity_TEXT_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_text_value_get", _wrap_Dwg_Entity_TEXT_text_value_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_generation_set", _wrap_Dwg_Entity_TEXT_generation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_generation_get", _wrap_Dwg_Entity_TEXT_generation_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_horiz_alignment_set", _wrap_Dwg_Entity_TEXT_horiz_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_horiz_alignment_get", _wrap_Dwg_Entity_TEXT_horiz_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_vert_alignment_set", _wrap_Dwg_Entity_TEXT_vert_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_vert_alignment_get", _wrap_Dwg_Entity_TEXT_vert_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_TEXT_style_set", _wrap_Dwg_Entity_TEXT_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TEXT_style_get", _wrap_Dwg_Entity_TEXT_style_get, METH_O, NULL},
	 { "new_Dwg_Entity_TEXT", _wrap_new_Dwg_Entity_TEXT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_TEXT", _wrap_delete_Dwg_Entity_TEXT, METH_O, NULL},
	 { "Dwg_Entity_TEXT_swigregister", Dwg_Entity_TEXT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_TEXT_swiginit", Dwg_Entity_TEXT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_attachment_set", _wrap_Dwg_AcDbMTextObjectEmbedded_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_attachment_get", _wrap_Dwg_AcDbMTextObjectEmbedded_attachment_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_ins_pt_set", _wrap_Dwg_AcDbMTextObjectEmbedded_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_ins_pt_get", _wrap_Dwg_AcDbMTextObjectEmbedded_ins_pt_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set", _wrap_Dwg_AcDbMTextObjectEmbedded_x_axis_dir_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_x_axis_dir_get", _wrap_Dwg_AcDbMTextObjectEmbedded_x_axis_dir_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_rect_height_set", _wrap_Dwg_AcDbMTextObjectEmbedded_rect_height_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_rect_height_get", _wrap_Dwg_AcDbMTextObjectEmbedded_rect_height_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_rect_width_set", _wrap_Dwg_AcDbMTextObjectEmbedded_rect_width_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_rect_width_get", _wrap_Dwg_AcDbMTextObjectEmbedded_rect_width_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_extents_width_set", _wrap_Dwg_AcDbMTextObjectEmbedded_extents_width_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_extents_width_get", _wrap_Dwg_AcDbMTextObjectEmbedded_extents_width_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_extents_height_set", _wrap_Dwg_AcDbMTextObjectEmbedded_extents_height_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_extents_height_get", _wrap_Dwg_AcDbMTextObjectEmbedded_extents_height_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_type_set", _wrap_Dwg_AcDbMTextObjectEmbedded_column_type_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_type_get", _wrap_Dwg_AcDbMTextObjectEmbedded_column_type_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_width_set", _wrap_Dwg_AcDbMTextObjectEmbedded_column_width_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_width_get", _wrap_Dwg_AcDbMTextObjectEmbedded_column_width_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_gutter_set", _wrap_Dwg_AcDbMTextObjectEmbedded_gutter_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_gutter_get", _wrap_Dwg_AcDbMTextObjectEmbedded_gutter_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_auto_height_set", _wrap_Dwg_AcDbMTextObjectEmbedded_auto_height_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_auto_height_get", _wrap_Dwg_AcDbMTextObjectEmbedded_auto_height_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_flow_reversed_set", _wrap_Dwg_AcDbMTextObjectEmbedded_flow_reversed_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_flow_reversed_get", _wrap_Dwg_AcDbMTextObjectEmbedded_flow_reversed_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_num_column_heights_set", _wrap_Dwg_AcDbMTextObjectEmbedded_num_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_num_column_heights_get", _wrap_Dwg_AcDbMTextObjectEmbedded_num_column_heights_get, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_heights_set", _wrap_Dwg_AcDbMTextObjectEmbedded_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_column_heights_get", _wrap_Dwg_AcDbMTextObjectEmbedded_column_heights_get, METH_O, NULL},
	 { "new_Dwg_AcDbMTextObjectEmbedded", _wrap_new_Dwg_AcDbMTextObjectEmbedded, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDbMTextObjectEmbedded", _wrap_delete_Dwg_AcDbMTextObjectEmbedded, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_swigregister", Dwg_AcDbMTextObjectEmbedded_swigregister, METH_O, NULL},
	 { "Dwg_AcDbMTextObjectEmbedded_swiginit", Dwg_AcDbMTextObjectEmbedded_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_parent_set", _wrap_Dwg_Entity_ATTRIB_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_parent_get", _wrap_Dwg_Entity_ATTRIB_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_elevation_set", _wrap_Dwg_Entity_ATTRIB_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_elevation_get", _wrap_Dwg_Entity_ATTRIB_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_ins_pt_set", _wrap_Dwg_Entity_ATTRIB_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_ins_pt_get", _wrap_Dwg_Entity_ATTRIB_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_alignment_pt_set", _wrap_Dwg_Entity_ATTRIB_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_alignment_pt_get", _wrap_Dwg_Entity_ATTRIB_alignment_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_extrusion_set", _wrap_Dwg_Entity_ATTRIB_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_extrusion_get", _wrap_Dwg_Entity_ATTRIB_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_thickness_set", _wrap_Dwg_Entity_ATTRIB_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_thickness_get", _wrap_Dwg_Entity_ATTRIB_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_oblique_angle_set", _wrap_Dwg_Entity_ATTRIB_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_oblique_angle_get", _wrap_Dwg_Entity_ATTRIB_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_rotation_set", _wrap_Dwg_Entity_ATTRIB_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_rotation_get", _wrap_Dwg_Entity_ATTRIB_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_height_set", _wrap_Dwg_Entity_ATTRIB_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_height_get", _wrap_Dwg_Entity_ATTRIB_height_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_width_factor_set", _wrap_Dwg_Entity_ATTRIB_width_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_width_factor_get", _wrap_Dwg_Entity_ATTRIB_width_factor_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_text_value_set", _wrap_Dwg_Entity_ATTRIB_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_text_value_get", _wrap_Dwg_Entity_ATTRIB_text_value_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_generation_set", _wrap_Dwg_Entity_ATTRIB_generation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_generation_get", _wrap_Dwg_Entity_ATTRIB_generation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_horiz_alignment_set", _wrap_Dwg_Entity_ATTRIB_horiz_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_horiz_alignment_get", _wrap_Dwg_Entity_ATTRIB_horiz_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_vert_alignment_set", _wrap_Dwg_Entity_ATTRIB_vert_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_vert_alignment_get", _wrap_Dwg_Entity_ATTRIB_vert_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_dataflags_set", _wrap_Dwg_Entity_ATTRIB_dataflags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_dataflags_get", _wrap_Dwg_Entity_ATTRIB_dataflags_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_is_locked_in_block_set", _wrap_Dwg_Entity_ATTRIB_is_locked_in_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_is_locked_in_block_get", _wrap_Dwg_Entity_ATTRIB_is_locked_in_block_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_keep_duplicate_records_set", _wrap_Dwg_Entity_ATTRIB_keep_duplicate_records_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_keep_duplicate_records_get", _wrap_Dwg_Entity_ATTRIB_keep_duplicate_records_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_tag_set", _wrap_Dwg_Entity_ATTRIB_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_tag_get", _wrap_Dwg_Entity_ATTRIB_tag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_field_length_set", _wrap_Dwg_Entity_ATTRIB_field_length_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_field_length_get", _wrap_Dwg_Entity_ATTRIB_field_length_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_flags_set", _wrap_Dwg_Entity_ATTRIB_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_flags_get", _wrap_Dwg_Entity_ATTRIB_flags_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_lock_position_flag_set", _wrap_Dwg_Entity_ATTRIB_lock_position_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_lock_position_flag_get", _wrap_Dwg_Entity_ATTRIB_lock_position_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_style_set", _wrap_Dwg_Entity_ATTRIB_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_style_get", _wrap_Dwg_Entity_ATTRIB_style_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_mtext_type_set", _wrap_Dwg_Entity_ATTRIB_mtext_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_mtext_type_get", _wrap_Dwg_Entity_ATTRIB_mtext_type_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_mtext_set", _wrap_Dwg_Entity_ATTRIB_mtext_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_mtext_get", _wrap_Dwg_Entity_ATTRIB_mtext_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_is_really_locked_set", _wrap_Dwg_Entity_ATTRIB_is_really_locked_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_is_really_locked_get", _wrap_Dwg_Entity_ATTRIB_is_really_locked_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_data_size_set", _wrap_Dwg_Entity_ATTRIB_annotative_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_data_size_get", _wrap_Dwg_Entity_ATTRIB_annotative_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_data_set", _wrap_Dwg_Entity_ATTRIB_annotative_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_data_get", _wrap_Dwg_Entity_ATTRIB_annotative_data_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_flag_set", _wrap_Dwg_Entity_ATTRIB_annotative_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_flag_get", _wrap_Dwg_Entity_ATTRIB_annotative_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_style_set", _wrap_Dwg_Entity_ATTRIB_annotative_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTRIB_annotative_style_get", _wrap_Dwg_Entity_ATTRIB_annotative_style_get, METH_O, NULL},
	 { "new_Dwg_Entity_ATTRIB", _wrap_new_Dwg_Entity_ATTRIB, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ATTRIB", _wrap_delete_Dwg_Entity_ATTRIB, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_swigregister", Dwg_Entity_ATTRIB_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ATTRIB_swiginit", Dwg_Entity_ATTRIB_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_parent_set", _wrap_Dwg_Entity_ATTDEF_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_parent_get", _wrap_Dwg_Entity_ATTDEF_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_elevation_set", _wrap_Dwg_Entity_ATTDEF_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_elevation_get", _wrap_Dwg_Entity_ATTDEF_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_ins_pt_set", _wrap_Dwg_Entity_ATTDEF_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_ins_pt_get", _wrap_Dwg_Entity_ATTDEF_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_alignment_pt_set", _wrap_Dwg_Entity_ATTDEF_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_alignment_pt_get", _wrap_Dwg_Entity_ATTDEF_alignment_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_extrusion_set", _wrap_Dwg_Entity_ATTDEF_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_extrusion_get", _wrap_Dwg_Entity_ATTDEF_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_thickness_set", _wrap_Dwg_Entity_ATTDEF_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_thickness_get", _wrap_Dwg_Entity_ATTDEF_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_oblique_angle_set", _wrap_Dwg_Entity_ATTDEF_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_oblique_angle_get", _wrap_Dwg_Entity_ATTDEF_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_rotation_set", _wrap_Dwg_Entity_ATTDEF_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_rotation_get", _wrap_Dwg_Entity_ATTDEF_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_height_set", _wrap_Dwg_Entity_ATTDEF_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_height_get", _wrap_Dwg_Entity_ATTDEF_height_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_width_factor_set", _wrap_Dwg_Entity_ATTDEF_width_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_width_factor_get", _wrap_Dwg_Entity_ATTDEF_width_factor_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_default_value_set", _wrap_Dwg_Entity_ATTDEF_default_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_default_value_get", _wrap_Dwg_Entity_ATTDEF_default_value_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_generation_set", _wrap_Dwg_Entity_ATTDEF_generation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_generation_get", _wrap_Dwg_Entity_ATTDEF_generation_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_horiz_alignment_set", _wrap_Dwg_Entity_ATTDEF_horiz_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_horiz_alignment_get", _wrap_Dwg_Entity_ATTDEF_horiz_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_vert_alignment_set", _wrap_Dwg_Entity_ATTDEF_vert_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_vert_alignment_get", _wrap_Dwg_Entity_ATTDEF_vert_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_dataflags_set", _wrap_Dwg_Entity_ATTDEF_dataflags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_dataflags_get", _wrap_Dwg_Entity_ATTDEF_dataflags_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_is_locked_in_block_set", _wrap_Dwg_Entity_ATTDEF_is_locked_in_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_is_locked_in_block_get", _wrap_Dwg_Entity_ATTDEF_is_locked_in_block_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_keep_duplicate_records_set", _wrap_Dwg_Entity_ATTDEF_keep_duplicate_records_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_keep_duplicate_records_get", _wrap_Dwg_Entity_ATTDEF_keep_duplicate_records_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_tag_set", _wrap_Dwg_Entity_ATTDEF_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_tag_get", _wrap_Dwg_Entity_ATTDEF_tag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_field_length_set", _wrap_Dwg_Entity_ATTDEF_field_length_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_field_length_get", _wrap_Dwg_Entity_ATTDEF_field_length_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_flags_set", _wrap_Dwg_Entity_ATTDEF_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_flags_get", _wrap_Dwg_Entity_ATTDEF_flags_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_lock_position_flag_set", _wrap_Dwg_Entity_ATTDEF_lock_position_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_lock_position_flag_get", _wrap_Dwg_Entity_ATTDEF_lock_position_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_style_set", _wrap_Dwg_Entity_ATTDEF_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_style_get", _wrap_Dwg_Entity_ATTDEF_style_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_mtext_type_set", _wrap_Dwg_Entity_ATTDEF_mtext_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_mtext_type_get", _wrap_Dwg_Entity_ATTDEF_mtext_type_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_mtext_set", _wrap_Dwg_Entity_ATTDEF_mtext_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_mtext_get", _wrap_Dwg_Entity_ATTDEF_mtext_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_is_really_locked_set", _wrap_Dwg_Entity_ATTDEF_is_really_locked_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_is_really_locked_get", _wrap_Dwg_Entity_ATTDEF_is_really_locked_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_data_size_set", _wrap_Dwg_Entity_ATTDEF_annotative_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_data_size_get", _wrap_Dwg_Entity_ATTDEF_annotative_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_data_set", _wrap_Dwg_Entity_ATTDEF_annotative_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_data_get", _wrap_Dwg_Entity_ATTDEF_annotative_data_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_flag_set", _wrap_Dwg_Entity_ATTDEF_annotative_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_flag_get", _wrap_Dwg_Entity_ATTDEF_annotative_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_style_set", _wrap_Dwg_Entity_ATTDEF_annotative_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_annotative_style_get", _wrap_Dwg_Entity_ATTDEF_annotative_style_get, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_prompt_set", _wrap_Dwg_Entity_ATTDEF_prompt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ATTDEF_prompt_get", _wrap_Dwg_Entity_ATTDEF_prompt_get, METH_O, NULL},
	 { "new_Dwg_Entity_ATTDEF", _wrap_new_Dwg_Entity_ATTDEF, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ATTDEF", _wrap_delete_Dwg_Entity_ATTDEF, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_swigregister", Dwg_Entity_ATTDEF_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ATTDEF_swiginit", Dwg_Entity_ATTDEF_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_BLOCK_parent_set", _wrap_Dwg_Entity_BLOCK_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_BLOCK_parent_get", _wrap_Dwg_Entity_BLOCK_parent_get, METH_O, NULL},
	 { "Dwg_Entity_BLOCK_name_set", _wrap_Dwg_Entity_BLOCK_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_BLOCK_name_get", _wrap_Dwg_Entity_BLOCK_name_get, METH_O, NULL},
	 { "Dwg_Entity_BLOCK_xref_pname_set", _wrap_Dwg_Entity_BLOCK_xref_pname_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_BLOCK_xref_pname_get", _wrap_Dwg_Entity_BLOCK_xref_pname_get, METH_O, NULL},
	 { "Dwg_Entity_BLOCK_base_pt_set", _wrap_Dwg_Entity_BLOCK_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_BLOCK_base_pt_get", _wrap_Dwg_Entity_BLOCK_base_pt_get, METH_O, NULL},
	 { "new_Dwg_Entity_BLOCK", _wrap_new_Dwg_Entity_BLOCK, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_BLOCK", _wrap_delete_Dwg_Entity_BLOCK, METH_O, NULL},
	 { "Dwg_Entity_BLOCK_swigregister", Dwg_Entity_BLOCK_swigregister, METH_O, NULL},
	 { "Dwg_Entity_BLOCK_swiginit", Dwg_Entity_BLOCK_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDBLK_parent_set", _wrap_Dwg_Entity_ENDBLK_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDBLK_parent_get", _wrap_Dwg_Entity_ENDBLK_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_ENDBLK", _wrap_new_Dwg_Entity_ENDBLK, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ENDBLK", _wrap_delete_Dwg_Entity_ENDBLK, METH_O, NULL},
	 { "Dwg_Entity_ENDBLK_swigregister", Dwg_Entity_ENDBLK_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ENDBLK_swiginit", Dwg_Entity_ENDBLK_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SEQEND_parent_set", _wrap_Dwg_Entity_SEQEND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SEQEND_parent_get", _wrap_Dwg_Entity_SEQEND_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SEQEND_begin_addr_r11_set", _wrap_Dwg_Entity_SEQEND_begin_addr_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SEQEND_begin_addr_r11_get", _wrap_Dwg_Entity_SEQEND_begin_addr_r11_get, METH_O, NULL},
	 { "new_Dwg_Entity_SEQEND", _wrap_new_Dwg_Entity_SEQEND, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SEQEND", _wrap_delete_Dwg_Entity_SEQEND, METH_O, NULL},
	 { "Dwg_Entity_SEQEND_swigregister", Dwg_Entity_SEQEND_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SEQEND_swiginit", Dwg_Entity_SEQEND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_parent_set", _wrap_Dwg_Entity_INSERT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_parent_get", _wrap_Dwg_Entity_INSERT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_ins_pt_set", _wrap_Dwg_Entity_INSERT_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_ins_pt_get", _wrap_Dwg_Entity_INSERT_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_scale_flag_set", _wrap_Dwg_Entity_INSERT_scale_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_scale_flag_get", _wrap_Dwg_Entity_INSERT_scale_flag_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_scale_set", _wrap_Dwg_Entity_INSERT_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_scale_get", _wrap_Dwg_Entity_INSERT_scale_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_rotation_set", _wrap_Dwg_Entity_INSERT_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_rotation_get", _wrap_Dwg_Entity_INSERT_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_extrusion_set", _wrap_Dwg_Entity_INSERT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_extrusion_get", _wrap_Dwg_Entity_INSERT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_has_attribs_set", _wrap_Dwg_Entity_INSERT_has_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_has_attribs_get", _wrap_Dwg_Entity_INSERT_has_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_num_owned_set", _wrap_Dwg_Entity_INSERT_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_num_owned_get", _wrap_Dwg_Entity_INSERT_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_block_header_set", _wrap_Dwg_Entity_INSERT_block_header_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_block_header_get", _wrap_Dwg_Entity_INSERT_block_header_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_first_attrib_set", _wrap_Dwg_Entity_INSERT_first_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_first_attrib_get", _wrap_Dwg_Entity_INSERT_first_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_last_attrib_set", _wrap_Dwg_Entity_INSERT_last_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_last_attrib_get", _wrap_Dwg_Entity_INSERT_last_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_attribs_set", _wrap_Dwg_Entity_INSERT_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_attribs_get", _wrap_Dwg_Entity_INSERT_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_seqend_set", _wrap_Dwg_Entity_INSERT_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_seqend_get", _wrap_Dwg_Entity_INSERT_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_num_cols_set", _wrap_Dwg_Entity_INSERT_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_num_cols_get", _wrap_Dwg_Entity_INSERT_num_cols_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_num_rows_set", _wrap_Dwg_Entity_INSERT_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_num_rows_get", _wrap_Dwg_Entity_INSERT_num_rows_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_col_spacing_set", _wrap_Dwg_Entity_INSERT_col_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_col_spacing_get", _wrap_Dwg_Entity_INSERT_col_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_row_spacing_set", _wrap_Dwg_Entity_INSERT_row_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_row_spacing_get", _wrap_Dwg_Entity_INSERT_row_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_INSERT_block_name_set", _wrap_Dwg_Entity_INSERT_block_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_INSERT_block_name_get", _wrap_Dwg_Entity_INSERT_block_name_get, METH_O, NULL},
	 { "new_Dwg_Entity_INSERT", _wrap_new_Dwg_Entity_INSERT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_INSERT", _wrap_delete_Dwg_Entity_INSERT, METH_O, NULL},
	 { "Dwg_Entity_INSERT_swigregister", Dwg_Entity_INSERT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_INSERT_swiginit", Dwg_Entity_INSERT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_parent_set", _wrap_Dwg_Entity_MINSERT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_parent_get", _wrap_Dwg_Entity_MINSERT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_ins_pt_set", _wrap_Dwg_Entity_MINSERT_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_ins_pt_get", _wrap_Dwg_Entity_MINSERT_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_scale_flag_set", _wrap_Dwg_Entity_MINSERT_scale_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_scale_flag_get", _wrap_Dwg_Entity_MINSERT_scale_flag_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_scale_set", _wrap_Dwg_Entity_MINSERT_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_scale_get", _wrap_Dwg_Entity_MINSERT_scale_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_rotation_set", _wrap_Dwg_Entity_MINSERT_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_rotation_get", _wrap_Dwg_Entity_MINSERT_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_extrusion_set", _wrap_Dwg_Entity_MINSERT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_extrusion_get", _wrap_Dwg_Entity_MINSERT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_has_attribs_set", _wrap_Dwg_Entity_MINSERT_has_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_has_attribs_get", _wrap_Dwg_Entity_MINSERT_has_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_num_owned_set", _wrap_Dwg_Entity_MINSERT_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_num_owned_get", _wrap_Dwg_Entity_MINSERT_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_num_cols_set", _wrap_Dwg_Entity_MINSERT_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_num_cols_get", _wrap_Dwg_Entity_MINSERT_num_cols_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_num_rows_set", _wrap_Dwg_Entity_MINSERT_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_num_rows_get", _wrap_Dwg_Entity_MINSERT_num_rows_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_col_spacing_set", _wrap_Dwg_Entity_MINSERT_col_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_col_spacing_get", _wrap_Dwg_Entity_MINSERT_col_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_row_spacing_set", _wrap_Dwg_Entity_MINSERT_row_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_row_spacing_get", _wrap_Dwg_Entity_MINSERT_row_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_block_header_set", _wrap_Dwg_Entity_MINSERT_block_header_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_block_header_get", _wrap_Dwg_Entity_MINSERT_block_header_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_first_attrib_set", _wrap_Dwg_Entity_MINSERT_first_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_first_attrib_get", _wrap_Dwg_Entity_MINSERT_first_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_last_attrib_set", _wrap_Dwg_Entity_MINSERT_last_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_last_attrib_get", _wrap_Dwg_Entity_MINSERT_last_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_attribs_set", _wrap_Dwg_Entity_MINSERT_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_attribs_get", _wrap_Dwg_Entity_MINSERT_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_seqend_set", _wrap_Dwg_Entity_MINSERT_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MINSERT_seqend_get", _wrap_Dwg_Entity_MINSERT_seqend_get, METH_O, NULL},
	 { "new_Dwg_Entity_MINSERT", _wrap_new_Dwg_Entity_MINSERT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MINSERT", _wrap_delete_Dwg_Entity_MINSERT, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_swigregister", Dwg_Entity_MINSERT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MINSERT_swiginit", Dwg_Entity_MINSERT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_parent_set", _wrap_Dwg_Entity_VERTEX_2D_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_parent_get", _wrap_Dwg_Entity_VERTEX_2D_parent_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_flag_set", _wrap_Dwg_Entity_VERTEX_2D_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_flag_get", _wrap_Dwg_Entity_VERTEX_2D_flag_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_point_set", _wrap_Dwg_Entity_VERTEX_2D_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_point_get", _wrap_Dwg_Entity_VERTEX_2D_point_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_start_width_set", _wrap_Dwg_Entity_VERTEX_2D_start_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_start_width_get", _wrap_Dwg_Entity_VERTEX_2D_start_width_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_end_width_set", _wrap_Dwg_Entity_VERTEX_2D_end_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_end_width_get", _wrap_Dwg_Entity_VERTEX_2D_end_width_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_id_set", _wrap_Dwg_Entity_VERTEX_2D_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_id_get", _wrap_Dwg_Entity_VERTEX_2D_id_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_bulge_set", _wrap_Dwg_Entity_VERTEX_2D_bulge_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_bulge_get", _wrap_Dwg_Entity_VERTEX_2D_bulge_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_tangent_dir_set", _wrap_Dwg_Entity_VERTEX_2D_tangent_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_2D_tangent_dir_get", _wrap_Dwg_Entity_VERTEX_2D_tangent_dir_get, METH_O, NULL},
	 { "new_Dwg_Entity_VERTEX_2D", _wrap_new_Dwg_Entity_VERTEX_2D, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VERTEX_2D", _wrap_delete_Dwg_Entity_VERTEX_2D, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_swigregister", Dwg_Entity_VERTEX_2D_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_2D_swiginit", Dwg_Entity_VERTEX_2D_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_3D_parent_set", _wrap_Dwg_Entity_VERTEX_3D_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_3D_parent_get", _wrap_Dwg_Entity_VERTEX_3D_parent_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_3D_flag_set", _wrap_Dwg_Entity_VERTEX_3D_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_3D_flag_get", _wrap_Dwg_Entity_VERTEX_3D_flag_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_3D_point_set", _wrap_Dwg_Entity_VERTEX_3D_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_3D_point_get", _wrap_Dwg_Entity_VERTEX_3D_point_get, METH_O, NULL},
	 { "new_Dwg_Entity_VERTEX_3D", _wrap_new_Dwg_Entity_VERTEX_3D, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VERTEX_3D", _wrap_delete_Dwg_Entity_VERTEX_3D, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_3D_swigregister", Dwg_Entity_VERTEX_3D_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_3D_swiginit", Dwg_Entity_VERTEX_3D_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_parent_set", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_parent_get", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_flag_set", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_flag_get", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_flag_get, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_vertind_set", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_vertind_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_vertind_get", _wrap_Dwg_Entity_VERTEX_PFACE_FACE_vertind_get, METH_O, NULL},
	 { "new_Dwg_Entity_VERTEX_PFACE_FACE", _wrap_new_Dwg_Entity_VERTEX_PFACE_FACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VERTEX_PFACE_FACE", _wrap_delete_Dwg_Entity_VERTEX_PFACE_FACE, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_swigregister", Dwg_Entity_VERTEX_PFACE_FACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VERTEX_PFACE_FACE_swiginit", Dwg_Entity_VERTEX_PFACE_FACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_parent_set", _wrap_Dwg_Entity_POLYLINE_2D_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_parent_get", _wrap_Dwg_Entity_POLYLINE_2D_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_has_vertex_set", _wrap_Dwg_Entity_POLYLINE_2D_has_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_has_vertex_get", _wrap_Dwg_Entity_POLYLINE_2D_has_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_owned_set", _wrap_Dwg_Entity_POLYLINE_2D_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_owned_get", _wrap_Dwg_Entity_POLYLINE_2D_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_first_vertex_set", _wrap_Dwg_Entity_POLYLINE_2D_first_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_first_vertex_get", _wrap_Dwg_Entity_POLYLINE_2D_first_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_last_vertex_set", _wrap_Dwg_Entity_POLYLINE_2D_last_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_last_vertex_get", _wrap_Dwg_Entity_POLYLINE_2D_last_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_vertex_set", _wrap_Dwg_Entity_POLYLINE_2D_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_vertex_get", _wrap_Dwg_Entity_POLYLINE_2D_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_seqend_set", _wrap_Dwg_Entity_POLYLINE_2D_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_seqend_get", _wrap_Dwg_Entity_POLYLINE_2D_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_flag_set", _wrap_Dwg_Entity_POLYLINE_2D_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_flag_get", _wrap_Dwg_Entity_POLYLINE_2D_flag_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_curve_type_set", _wrap_Dwg_Entity_POLYLINE_2D_curve_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_curve_type_get", _wrap_Dwg_Entity_POLYLINE_2D_curve_type_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_start_width_set", _wrap_Dwg_Entity_POLYLINE_2D_start_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_start_width_get", _wrap_Dwg_Entity_POLYLINE_2D_start_width_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_end_width_set", _wrap_Dwg_Entity_POLYLINE_2D_end_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_end_width_get", _wrap_Dwg_Entity_POLYLINE_2D_end_width_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_thickness_set", _wrap_Dwg_Entity_POLYLINE_2D_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_thickness_get", _wrap_Dwg_Entity_POLYLINE_2D_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_elevation_set", _wrap_Dwg_Entity_POLYLINE_2D_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_elevation_get", _wrap_Dwg_Entity_POLYLINE_2D_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extrusion_set", _wrap_Dwg_Entity_POLYLINE_2D_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extrusion_get", _wrap_Dwg_Entity_POLYLINE_2D_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extra_r11_size_set", _wrap_Dwg_Entity_POLYLINE_2D_extra_r11_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extra_r11_size_get", _wrap_Dwg_Entity_POLYLINE_2D_extra_r11_size_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extra_r11_text_set", _wrap_Dwg_Entity_POLYLINE_2D_extra_r11_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_extra_r11_text_get", _wrap_Dwg_Entity_POLYLINE_2D_extra_r11_text_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_m_verts_set", _wrap_Dwg_Entity_POLYLINE_2D_num_m_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_m_verts_get", _wrap_Dwg_Entity_POLYLINE_2D_num_m_verts_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_n_verts_set", _wrap_Dwg_Entity_POLYLINE_2D_num_n_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_2D_num_n_verts_get", _wrap_Dwg_Entity_POLYLINE_2D_num_n_verts_get, METH_O, NULL},
	 { "new_Dwg_Entity_POLYLINE_2D", _wrap_new_Dwg_Entity_POLYLINE_2D, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POLYLINE_2D", _wrap_delete_Dwg_Entity_POLYLINE_2D, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_swigregister", Dwg_Entity_POLYLINE_2D_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_2D_swiginit", Dwg_Entity_POLYLINE_2D_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_parent_set", _wrap_Dwg_Entity_POLYLINE_3D_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_parent_get", _wrap_Dwg_Entity_POLYLINE_3D_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_has_vertex_set", _wrap_Dwg_Entity_POLYLINE_3D_has_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_has_vertex_get", _wrap_Dwg_Entity_POLYLINE_3D_has_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_num_owned_set", _wrap_Dwg_Entity_POLYLINE_3D_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_num_owned_get", _wrap_Dwg_Entity_POLYLINE_3D_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_first_vertex_set", _wrap_Dwg_Entity_POLYLINE_3D_first_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_first_vertex_get", _wrap_Dwg_Entity_POLYLINE_3D_first_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_last_vertex_set", _wrap_Dwg_Entity_POLYLINE_3D_last_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_last_vertex_get", _wrap_Dwg_Entity_POLYLINE_3D_last_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_vertex_set", _wrap_Dwg_Entity_POLYLINE_3D_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_vertex_get", _wrap_Dwg_Entity_POLYLINE_3D_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_seqend_set", _wrap_Dwg_Entity_POLYLINE_3D_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_seqend_get", _wrap_Dwg_Entity_POLYLINE_3D_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_curve_type_set", _wrap_Dwg_Entity_POLYLINE_3D_curve_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_curve_type_get", _wrap_Dwg_Entity_POLYLINE_3D_curve_type_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_start_width_set", _wrap_Dwg_Entity_POLYLINE_3D_start_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_start_width_get", _wrap_Dwg_Entity_POLYLINE_3D_start_width_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_end_width_set", _wrap_Dwg_Entity_POLYLINE_3D_end_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_end_width_get", _wrap_Dwg_Entity_POLYLINE_3D_end_width_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_flag_set", _wrap_Dwg_Entity_POLYLINE_3D_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_flag_get", _wrap_Dwg_Entity_POLYLINE_3D_flag_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_extrusion_set", _wrap_Dwg_Entity_POLYLINE_3D_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_3D_extrusion_get", _wrap_Dwg_Entity_POLYLINE_3D_extrusion_get, METH_O, NULL},
	 { "new_Dwg_Entity_POLYLINE_3D", _wrap_new_Dwg_Entity_POLYLINE_3D, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POLYLINE_3D", _wrap_delete_Dwg_Entity_POLYLINE_3D, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_swigregister", Dwg_Entity_POLYLINE_3D_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_3D_swiginit", Dwg_Entity_POLYLINE_3D_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_parent_set", _wrap_Dwg_Entity_ARC_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_parent_get", _wrap_Dwg_Entity_ARC_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_center_set", _wrap_Dwg_Entity_ARC_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_center_get", _wrap_Dwg_Entity_ARC_center_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_radius_set", _wrap_Dwg_Entity_ARC_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_radius_get", _wrap_Dwg_Entity_ARC_radius_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_thickness_set", _wrap_Dwg_Entity_ARC_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_thickness_get", _wrap_Dwg_Entity_ARC_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_extrusion_set", _wrap_Dwg_Entity_ARC_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_extrusion_get", _wrap_Dwg_Entity_ARC_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_start_angle_set", _wrap_Dwg_Entity_ARC_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_start_angle_get", _wrap_Dwg_Entity_ARC_start_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_end_angle_set", _wrap_Dwg_Entity_ARC_end_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_end_angle_get", _wrap_Dwg_Entity_ARC_end_angle_get, METH_O, NULL},
	 { "new_Dwg_Entity_ARC", _wrap_new_Dwg_Entity_ARC, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ARC", _wrap_delete_Dwg_Entity_ARC, METH_O, NULL},
	 { "Dwg_Entity_ARC_swigregister", Dwg_Entity_ARC_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ARC_swiginit", Dwg_Entity_ARC_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_parent_set", _wrap_Dwg_Entity_CIRCLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_parent_get", _wrap_Dwg_Entity_CIRCLE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_center_set", _wrap_Dwg_Entity_CIRCLE_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_center_get", _wrap_Dwg_Entity_CIRCLE_center_get, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_radius_set", _wrap_Dwg_Entity_CIRCLE_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_radius_get", _wrap_Dwg_Entity_CIRCLE_radius_get, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_thickness_set", _wrap_Dwg_Entity_CIRCLE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_thickness_get", _wrap_Dwg_Entity_CIRCLE_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_extrusion_set", _wrap_Dwg_Entity_CIRCLE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CIRCLE_extrusion_get", _wrap_Dwg_Entity_CIRCLE_extrusion_get, METH_O, NULL},
	 { "new_Dwg_Entity_CIRCLE", _wrap_new_Dwg_Entity_CIRCLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_CIRCLE", _wrap_delete_Dwg_Entity_CIRCLE, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_swigregister", Dwg_Entity_CIRCLE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_CIRCLE_swiginit", Dwg_Entity_CIRCLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_parent_set", _wrap_Dwg_Entity_LINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_parent_get", _wrap_Dwg_Entity_LINE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_z_is_zero_set", _wrap_Dwg_Entity_LINE_z_is_zero_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_z_is_zero_get", _wrap_Dwg_Entity_LINE_z_is_zero_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_start_set", _wrap_Dwg_Entity_LINE_start_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_start_get", _wrap_Dwg_Entity_LINE_start_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_end_set", _wrap_Dwg_Entity_LINE_end_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_end_get", _wrap_Dwg_Entity_LINE_end_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_thickness_set", _wrap_Dwg_Entity_LINE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_thickness_get", _wrap_Dwg_Entity_LINE_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_extrusion_set", _wrap_Dwg_Entity_LINE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_extrusion_get", _wrap_Dwg_Entity_LINE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_LINE_unknown_r11_set", _wrap_Dwg_Entity_LINE_unknown_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINE_unknown_r11_get", _wrap_Dwg_Entity_LINE_unknown_r11_get, METH_O, NULL},
	 { "new_Dwg_Entity_LINE", _wrap_new_Dwg_Entity_LINE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LINE", _wrap_delete_Dwg_Entity_LINE, METH_O, NULL},
	 { "Dwg_Entity_LINE_swigregister", Dwg_Entity_LINE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LINE_swiginit", Dwg_Entity_LINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_parent_set", _wrap_Dwg_DIMENSION_common_parent_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_parent_get", _wrap_Dwg_DIMENSION_common_parent_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_class_version_set", _wrap_Dwg_DIMENSION_common_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_class_version_get", _wrap_Dwg_DIMENSION_common_class_version_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_extrusion_set", _wrap_Dwg_DIMENSION_common_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_extrusion_get", _wrap_Dwg_DIMENSION_common_extrusion_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_def_pt_set", _wrap_Dwg_DIMENSION_common_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_def_pt_get", _wrap_Dwg_DIMENSION_common_def_pt_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_text_midpt_set", _wrap_Dwg_DIMENSION_common_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_text_midpt_get", _wrap_Dwg_DIMENSION_common_text_midpt_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_elevation_set", _wrap_Dwg_DIMENSION_common_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_elevation_get", _wrap_Dwg_DIMENSION_common_elevation_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_flag_set", _wrap_Dwg_DIMENSION_common_flag_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_flag_get", _wrap_Dwg_DIMENSION_common_flag_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_flag1_set", _wrap_Dwg_DIMENSION_common_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_flag1_get", _wrap_Dwg_DIMENSION_common_flag1_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_user_text_set", _wrap_Dwg_DIMENSION_common_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_user_text_get", _wrap_Dwg_DIMENSION_common_user_text_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_text_rotation_set", _wrap_Dwg_DIMENSION_common_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_text_rotation_get", _wrap_Dwg_DIMENSION_common_text_rotation_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_horiz_dir_set", _wrap_Dwg_DIMENSION_common_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_horiz_dir_get", _wrap_Dwg_DIMENSION_common_horiz_dir_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_ins_scale_set", _wrap_Dwg_DIMENSION_common_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_ins_scale_get", _wrap_Dwg_DIMENSION_common_ins_scale_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_ins_rotation_set", _wrap_Dwg_DIMENSION_common_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_ins_rotation_get", _wrap_Dwg_DIMENSION_common_ins_rotation_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_attachment_set", _wrap_Dwg_DIMENSION_common_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_attachment_get", _wrap_Dwg_DIMENSION_common_attachment_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_lspace_style_set", _wrap_Dwg_DIMENSION_common_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_lspace_style_get", _wrap_Dwg_DIMENSION_common_lspace_style_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_lspace_factor_set", _wrap_Dwg_DIMENSION_common_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_lspace_factor_get", _wrap_Dwg_DIMENSION_common_lspace_factor_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_act_measurement_set", _wrap_Dwg_DIMENSION_common_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_act_measurement_get", _wrap_Dwg_DIMENSION_common_act_measurement_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_unknown_set", _wrap_Dwg_DIMENSION_common_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_unknown_get", _wrap_Dwg_DIMENSION_common_unknown_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_flip_arrow1_set", _wrap_Dwg_DIMENSION_common_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_flip_arrow1_get", _wrap_Dwg_DIMENSION_common_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_flip_arrow2_set", _wrap_Dwg_DIMENSION_common_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_flip_arrow2_get", _wrap_Dwg_DIMENSION_common_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_clone_ins_pt_set", _wrap_Dwg_DIMENSION_common_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_clone_ins_pt_get", _wrap_Dwg_DIMENSION_common_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_dimstyle_set", _wrap_Dwg_DIMENSION_common_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_dimstyle_get", _wrap_Dwg_DIMENSION_common_dimstyle_get, METH_O, NULL},
	 { "Dwg_DIMENSION_common_block_set", _wrap_Dwg_DIMENSION_common_block_set, METH_VARARGS, NULL},
	 { "Dwg_DIMENSION_common_block_get", _wrap_Dwg_DIMENSION_common_block_get, METH_O, NULL},
	 { "new_Dwg_DIMENSION_common", _wrap_new_Dwg_DIMENSION_common, METH_NOARGS, NULL},
	 { "delete_Dwg_DIMENSION_common", _wrap_delete_Dwg_DIMENSION_common, METH_O, NULL},
	 { "Dwg_DIMENSION_common_swigregister", Dwg_DIMENSION_common_swigregister, METH_O, NULL},
	 { "Dwg_DIMENSION_common_swiginit", Dwg_DIMENSION_common_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_parent_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_parent_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_class_version_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_class_version_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_extrusion_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_extrusion_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_def_pt_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_def_pt_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_elevation_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_elevation_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag1_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag1_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_user_text_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_user_text_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_attachment_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_attachment_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_unknown_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_unknown_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_block_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_block_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_feature_location_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_leader_endpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag2_set", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_flag2_get", _wrap_Dwg_Entity_DIMENSION_ORDINATE_flag2_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_ORDINATE", _wrap_new_Dwg_Entity_DIMENSION_ORDINATE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_ORDINATE", _wrap_delete_Dwg_Entity_DIMENSION_ORDINATE, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_swigregister", Dwg_Entity_DIMENSION_ORDINATE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ORDINATE_swiginit", Dwg_Entity_DIMENSION_ORDINATE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_parent_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_parent_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_class_version_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_class_version_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_extrusion_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_extrusion_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_def_pt_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_def_pt_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_elevation_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_elevation_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flag_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flag_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flag1_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flag1_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_user_text_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_user_text_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_attachment_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_attachment_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_unknown_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_unknown_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_block_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_block_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_xline1_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_xline1_pt_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_xline1_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_xline2_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_xline2_pt_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_xline2_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_oblique_angle_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set", _wrap_Dwg_Entity_DIMENSION_LINEAR_dim_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_dim_rotation_get", _wrap_Dwg_Entity_DIMENSION_LINEAR_dim_rotation_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_LINEAR", _wrap_new_Dwg_Entity_DIMENSION_LINEAR, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_LINEAR", _wrap_delete_Dwg_Entity_DIMENSION_LINEAR, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_swigregister", Dwg_Entity_DIMENSION_LINEAR_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_LINEAR_swiginit", Dwg_Entity_DIMENSION_LINEAR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_parent_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_parent_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_class_version_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_class_version_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_extrusion_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_extrusion_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_def_pt_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_def_pt_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_elevation_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_elevation_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flag_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flag_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flag1_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flag1_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_user_text_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_user_text_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_attachment_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_attachment_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_unknown_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_unknown_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_block_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_block_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_xline1_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_xline2_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set", _wrap_Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_get", _wrap_Dwg_Entity_DIMENSION_ALIGNED_oblique_angle_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_ALIGNED", _wrap_new_Dwg_Entity_DIMENSION_ALIGNED, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_ALIGNED", _wrap_delete_Dwg_Entity_DIMENSION_ALIGNED, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_swigregister", Dwg_Entity_DIMENSION_ALIGNED_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ALIGNED_swiginit", Dwg_Entity_DIMENSION_ALIGNED_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_parent_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_parent_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_class_version_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_class_version_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_extrusion_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_extrusion_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_def_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_def_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_elevation_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_elevation_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flag_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flag_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flag1_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flag1_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_user_text_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_user_text_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_attachment_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_attachment_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_unknown_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_unknown_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_block_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_block_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline1_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_center_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_center_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_center_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_center_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG3PT_xline2end_pt_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_ANG3PT", _wrap_new_Dwg_Entity_DIMENSION_ANG3PT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_ANG3PT", _wrap_delete_Dwg_Entity_DIMENSION_ANG3PT, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_swigregister", Dwg_Entity_DIMENSION_ANG3PT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG3PT_swiginit", Dwg_Entity_DIMENSION_ANG3PT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_parent_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_parent_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_class_version_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_class_version_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_extrusion_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_extrusion_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_def_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_def_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_elevation_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_elevation_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flag_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flag_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flag1_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flag1_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_user_text_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_user_text_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_attachment_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_attachment_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_unknown_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_unknown_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_block_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_block_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1start_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline1end_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2start_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_get", _wrap_Dwg_Entity_DIMENSION_ANG2LN_xline2end_pt_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_ANG2LN", _wrap_new_Dwg_Entity_DIMENSION_ANG2LN, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_ANG2LN", _wrap_delete_Dwg_Entity_DIMENSION_ANG2LN, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_swigregister", Dwg_Entity_DIMENSION_ANG2LN_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_ANG2LN_swiginit", Dwg_Entity_DIMENSION_ANG2LN_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_parent_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_parent_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_class_version_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_class_version_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_extrusion_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_extrusion_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_def_pt_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_def_pt_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_elevation_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_elevation_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flag_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flag_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flag1_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flag1_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_user_text_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_user_text_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_attachment_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_attachment_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_unknown_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_unknown_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_block_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_block_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_first_arc_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_leader_len_set", _wrap_Dwg_Entity_DIMENSION_RADIUS_leader_len_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_leader_len_get", _wrap_Dwg_Entity_DIMENSION_RADIUS_leader_len_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_RADIUS", _wrap_new_Dwg_Entity_DIMENSION_RADIUS, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_RADIUS", _wrap_delete_Dwg_Entity_DIMENSION_RADIUS, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_swigregister", Dwg_Entity_DIMENSION_RADIUS_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_RADIUS_swiginit", Dwg_Entity_DIMENSION_RADIUS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_parent_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_parent_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_class_version_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_class_version_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_extrusion_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_extrusion_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_def_pt_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_def_pt_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_text_midpt_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_elevation_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_elevation_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flag_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flag_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flag_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flag1_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flag1_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_user_text_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_user_text_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_text_rotation_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_ins_scale_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_attachment_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_attachment_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_lspace_style_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_act_measurement_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_unknown_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_unknown_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_dimstyle_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_block_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_block_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_block_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_first_arc_pt_get, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_leader_len_set", _wrap_Dwg_Entity_DIMENSION_DIAMETER_leader_len_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_leader_len_get", _wrap_Dwg_Entity_DIMENSION_DIAMETER_leader_len_get, METH_O, NULL},
	 { "new_Dwg_Entity_DIMENSION_DIAMETER", _wrap_new_Dwg_Entity_DIMENSION_DIAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_DIMENSION_DIAMETER", _wrap_delete_Dwg_Entity_DIMENSION_DIAMETER, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_swigregister", Dwg_Entity_DIMENSION_DIAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Entity_DIMENSION_DIAMETER_swiginit", Dwg_Entity_DIMENSION_DIAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_parent_set", _wrap_Dwg_Entity_ARC_DIMENSION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_parent_get", _wrap_Dwg_Entity_ARC_DIMENSION_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_class_version_set", _wrap_Dwg_Entity_ARC_DIMENSION_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_class_version_get", _wrap_Dwg_Entity_ARC_DIMENSION_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_extrusion_set", _wrap_Dwg_Entity_ARC_DIMENSION_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_extrusion_get", _wrap_Dwg_Entity_ARC_DIMENSION_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_def_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_def_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_text_midpt_set", _wrap_Dwg_Entity_ARC_DIMENSION_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_text_midpt_get", _wrap_Dwg_Entity_ARC_DIMENSION_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_elevation_set", _wrap_Dwg_Entity_ARC_DIMENSION_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_elevation_get", _wrap_Dwg_Entity_ARC_DIMENSION_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flag_set", _wrap_Dwg_Entity_ARC_DIMENSION_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flag_get", _wrap_Dwg_Entity_ARC_DIMENSION_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flag1_set", _wrap_Dwg_Entity_ARC_DIMENSION_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flag1_get", _wrap_Dwg_Entity_ARC_DIMENSION_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_user_text_set", _wrap_Dwg_Entity_ARC_DIMENSION_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_user_text_get", _wrap_Dwg_Entity_ARC_DIMENSION_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_text_rotation_set", _wrap_Dwg_Entity_ARC_DIMENSION_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_text_rotation_get", _wrap_Dwg_Entity_ARC_DIMENSION_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_horiz_dir_set", _wrap_Dwg_Entity_ARC_DIMENSION_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_horiz_dir_get", _wrap_Dwg_Entity_ARC_DIMENSION_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_ins_scale_set", _wrap_Dwg_Entity_ARC_DIMENSION_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_ins_scale_get", _wrap_Dwg_Entity_ARC_DIMENSION_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_ins_rotation_set", _wrap_Dwg_Entity_ARC_DIMENSION_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_ins_rotation_get", _wrap_Dwg_Entity_ARC_DIMENSION_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_attachment_set", _wrap_Dwg_Entity_ARC_DIMENSION_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_attachment_get", _wrap_Dwg_Entity_ARC_DIMENSION_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_lspace_style_set", _wrap_Dwg_Entity_ARC_DIMENSION_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_lspace_style_get", _wrap_Dwg_Entity_ARC_DIMENSION_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_lspace_factor_set", _wrap_Dwg_Entity_ARC_DIMENSION_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_lspace_factor_get", _wrap_Dwg_Entity_ARC_DIMENSION_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_act_measurement_set", _wrap_Dwg_Entity_ARC_DIMENSION_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_act_measurement_get", _wrap_Dwg_Entity_ARC_DIMENSION_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_unknown_set", _wrap_Dwg_Entity_ARC_DIMENSION_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_unknown_get", _wrap_Dwg_Entity_ARC_DIMENSION_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flip_arrow1_set", _wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flip_arrow1_get", _wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flip_arrow2_set", _wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_flip_arrow2_get", _wrap_Dwg_Entity_ARC_DIMENSION_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_clone_ins_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_dimstyle_set", _wrap_Dwg_Entity_ARC_DIMENSION_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_dimstyle_get", _wrap_Dwg_Entity_ARC_DIMENSION_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_block_set", _wrap_Dwg_Entity_ARC_DIMENSION_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_block_get", _wrap_Dwg_Entity_ARC_DIMENSION_block_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_xline1_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_xline1_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_xline1_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_xline1_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_xline2_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_xline2_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_xline2_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_xline2_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_center_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_center_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_center_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_center_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_is_partial_set", _wrap_Dwg_Entity_ARC_DIMENSION_is_partial_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_is_partial_get", _wrap_Dwg_Entity_ARC_DIMENSION_is_partial_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_arc_start_param_set", _wrap_Dwg_Entity_ARC_DIMENSION_arc_start_param_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_arc_start_param_get", _wrap_Dwg_Entity_ARC_DIMENSION_arc_start_param_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_arc_end_param_set", _wrap_Dwg_Entity_ARC_DIMENSION_arc_end_param_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_arc_end_param_get", _wrap_Dwg_Entity_ARC_DIMENSION_arc_end_param_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_has_leader_set", _wrap_Dwg_Entity_ARC_DIMENSION_has_leader_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_has_leader_get", _wrap_Dwg_Entity_ARC_DIMENSION_has_leader_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_leader1_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_leader1_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_leader1_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_leader1_pt_get, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_leader2_pt_set", _wrap_Dwg_Entity_ARC_DIMENSION_leader2_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_leader2_pt_get", _wrap_Dwg_Entity_ARC_DIMENSION_leader2_pt_get, METH_O, NULL},
	 { "new_Dwg_Entity_ARC_DIMENSION", _wrap_new_Dwg_Entity_ARC_DIMENSION, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ARC_DIMENSION", _wrap_delete_Dwg_Entity_ARC_DIMENSION, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_swigregister", Dwg_Entity_ARC_DIMENSION_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ARC_DIMENSION_swiginit", Dwg_Entity_ARC_DIMENSION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_def_pt_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_midpt_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flag1_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_user_text_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_text_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_horiz_dir_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_scale_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ins_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_style_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_lspace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_act_measurement_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow1_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_clone_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_dimstyle_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_block_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_block_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_block_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_angle_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_jog_pt_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_ovr_center_get, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_get", _wrap_Dwg_Entity_LARGE_RADIAL_DIMENSION_chord_pt_get, METH_O, NULL},
	 { "new_Dwg_Entity_LARGE_RADIAL_DIMENSION", _wrap_new_Dwg_Entity_LARGE_RADIAL_DIMENSION, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LARGE_RADIAL_DIMENSION", _wrap_delete_Dwg_Entity_LARGE_RADIAL_DIMENSION, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_swigregister", Dwg_Entity_LARGE_RADIAL_DIMENSION_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LARGE_RADIAL_DIMENSION_swiginit", Dwg_Entity_LARGE_RADIAL_DIMENSION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_parent_set", _wrap_Dwg_Entity_POINT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_parent_get", _wrap_Dwg_Entity_POINT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_x_set", _wrap_Dwg_Entity_POINT_x_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_x_get", _wrap_Dwg_Entity_POINT_x_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_y_set", _wrap_Dwg_Entity_POINT_y_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_y_get", _wrap_Dwg_Entity_POINT_y_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_z_set", _wrap_Dwg_Entity_POINT_z_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_z_get", _wrap_Dwg_Entity_POINT_z_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_thickness_set", _wrap_Dwg_Entity_POINT_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_thickness_get", _wrap_Dwg_Entity_POINT_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_extrusion_set", _wrap_Dwg_Entity_POINT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_extrusion_get", _wrap_Dwg_Entity_POINT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_POINT_x_ang_set", _wrap_Dwg_Entity_POINT_x_ang_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINT_x_ang_get", _wrap_Dwg_Entity_POINT_x_ang_get, METH_O, NULL},
	 { "new_Dwg_Entity_POINT", _wrap_new_Dwg_Entity_POINT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POINT", _wrap_delete_Dwg_Entity_POINT, METH_O, NULL},
	 { "Dwg_Entity_POINT_swigregister", Dwg_Entity_POINT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POINT_swiginit", Dwg_Entity_POINT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_parent_set", _wrap_Dwg_Entity__3DFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_parent_get", _wrap_Dwg_Entity__3DFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_has_no_flags_set", _wrap_Dwg_Entity__3DFACE_has_no_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_has_no_flags_get", _wrap_Dwg_Entity__3DFACE_has_no_flags_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_z_is_zero_set", _wrap_Dwg_Entity__3DFACE_z_is_zero_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_z_is_zero_get", _wrap_Dwg_Entity__3DFACE_z_is_zero_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_corner1_set", _wrap_Dwg_Entity__3DFACE_corner1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_corner1_get", _wrap_Dwg_Entity__3DFACE_corner1_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_corner2_set", _wrap_Dwg_Entity__3DFACE_corner2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_corner2_get", _wrap_Dwg_Entity__3DFACE_corner2_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_corner3_set", _wrap_Dwg_Entity__3DFACE_corner3_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_corner3_get", _wrap_Dwg_Entity__3DFACE_corner3_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_corner4_set", _wrap_Dwg_Entity__3DFACE_corner4_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_corner4_get", _wrap_Dwg_Entity__3DFACE_corner4_get, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_invis_flags_set", _wrap_Dwg_Entity__3DFACE_invis_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DFACE_invis_flags_get", _wrap_Dwg_Entity__3DFACE_invis_flags_get, METH_O, NULL},
	 { "new_Dwg_Entity__3DFACE", _wrap_new_Dwg_Entity__3DFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity__3DFACE", _wrap_delete_Dwg_Entity__3DFACE, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_swigregister", Dwg_Entity__3DFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity__3DFACE_swiginit", Dwg_Entity__3DFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_parent_set", _wrap_Dwg_Entity_POLYLINE_PFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_parent_get", _wrap_Dwg_Entity_POLYLINE_PFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_has_vertex_set", _wrap_Dwg_Entity_POLYLINE_PFACE_has_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_has_vertex_get", _wrap_Dwg_Entity_POLYLINE_PFACE_has_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_num_owned_set", _wrap_Dwg_Entity_POLYLINE_PFACE_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_num_owned_get", _wrap_Dwg_Entity_POLYLINE_PFACE_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_first_vertex_set", _wrap_Dwg_Entity_POLYLINE_PFACE_first_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_first_vertex_get", _wrap_Dwg_Entity_POLYLINE_PFACE_first_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_last_vertex_set", _wrap_Dwg_Entity_POLYLINE_PFACE_last_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_last_vertex_get", _wrap_Dwg_Entity_POLYLINE_PFACE_last_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_vertex_set", _wrap_Dwg_Entity_POLYLINE_PFACE_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_vertex_get", _wrap_Dwg_Entity_POLYLINE_PFACE_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_seqend_set", _wrap_Dwg_Entity_POLYLINE_PFACE_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_seqend_get", _wrap_Dwg_Entity_POLYLINE_PFACE_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_flag_set", _wrap_Dwg_Entity_POLYLINE_PFACE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_flag_get", _wrap_Dwg_Entity_POLYLINE_PFACE_flag_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_numverts_set", _wrap_Dwg_Entity_POLYLINE_PFACE_numverts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_numverts_get", _wrap_Dwg_Entity_POLYLINE_PFACE_numverts_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_numfaces_set", _wrap_Dwg_Entity_POLYLINE_PFACE_numfaces_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_numfaces_get", _wrap_Dwg_Entity_POLYLINE_PFACE_numfaces_get, METH_O, NULL},
	 { "new_Dwg_Entity_POLYLINE_PFACE", _wrap_new_Dwg_Entity_POLYLINE_PFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POLYLINE_PFACE", _wrap_delete_Dwg_Entity_POLYLINE_PFACE, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_swigregister", Dwg_Entity_POLYLINE_PFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_PFACE_swiginit", Dwg_Entity_POLYLINE_PFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_parent_set", _wrap_Dwg_Entity_POLYLINE_MESH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_parent_get", _wrap_Dwg_Entity_POLYLINE_MESH_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_has_vertex_set", _wrap_Dwg_Entity_POLYLINE_MESH_has_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_has_vertex_get", _wrap_Dwg_Entity_POLYLINE_MESH_has_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_owned_set", _wrap_Dwg_Entity_POLYLINE_MESH_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_owned_get", _wrap_Dwg_Entity_POLYLINE_MESH_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_first_vertex_set", _wrap_Dwg_Entity_POLYLINE_MESH_first_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_first_vertex_get", _wrap_Dwg_Entity_POLYLINE_MESH_first_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_last_vertex_set", _wrap_Dwg_Entity_POLYLINE_MESH_last_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_last_vertex_get", _wrap_Dwg_Entity_POLYLINE_MESH_last_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_vertex_set", _wrap_Dwg_Entity_POLYLINE_MESH_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_vertex_get", _wrap_Dwg_Entity_POLYLINE_MESH_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_seqend_set", _wrap_Dwg_Entity_POLYLINE_MESH_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_seqend_get", _wrap_Dwg_Entity_POLYLINE_MESH_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_flag_set", _wrap_Dwg_Entity_POLYLINE_MESH_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_flag_get", _wrap_Dwg_Entity_POLYLINE_MESH_flag_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_curve_type_set", _wrap_Dwg_Entity_POLYLINE_MESH_curve_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_curve_type_get", _wrap_Dwg_Entity_POLYLINE_MESH_curve_type_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_m_verts_set", _wrap_Dwg_Entity_POLYLINE_MESH_num_m_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_m_verts_get", _wrap_Dwg_Entity_POLYLINE_MESH_num_m_verts_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_n_verts_set", _wrap_Dwg_Entity_POLYLINE_MESH_num_n_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_num_n_verts_get", _wrap_Dwg_Entity_POLYLINE_MESH_num_n_verts_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_m_density_set", _wrap_Dwg_Entity_POLYLINE_MESH_m_density_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_m_density_get", _wrap_Dwg_Entity_POLYLINE_MESH_m_density_get, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_n_density_set", _wrap_Dwg_Entity_POLYLINE_MESH_n_density_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_n_density_get", _wrap_Dwg_Entity_POLYLINE_MESH_n_density_get, METH_O, NULL},
	 { "new_Dwg_Entity_POLYLINE_MESH", _wrap_new_Dwg_Entity_POLYLINE_MESH, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POLYLINE_MESH", _wrap_delete_Dwg_Entity_POLYLINE_MESH, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_swigregister", Dwg_Entity_POLYLINE_MESH_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POLYLINE_MESH_swiginit", Dwg_Entity_POLYLINE_MESH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_parent_set", _wrap_Dwg_Entity_SOLID_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_parent_get", _wrap_Dwg_Entity_SOLID_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_thickness_set", _wrap_Dwg_Entity_SOLID_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_thickness_get", _wrap_Dwg_Entity_SOLID_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_elevation_set", _wrap_Dwg_Entity_SOLID_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_elevation_get", _wrap_Dwg_Entity_SOLID_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_corner1_set", _wrap_Dwg_Entity_SOLID_corner1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_corner1_get", _wrap_Dwg_Entity_SOLID_corner1_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_corner2_set", _wrap_Dwg_Entity_SOLID_corner2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_corner2_get", _wrap_Dwg_Entity_SOLID_corner2_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_corner3_set", _wrap_Dwg_Entity_SOLID_corner3_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_corner3_get", _wrap_Dwg_Entity_SOLID_corner3_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_corner4_set", _wrap_Dwg_Entity_SOLID_corner4_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_corner4_get", _wrap_Dwg_Entity_SOLID_corner4_get, METH_O, NULL},
	 { "Dwg_Entity_SOLID_extrusion_set", _wrap_Dwg_Entity_SOLID_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SOLID_extrusion_get", _wrap_Dwg_Entity_SOLID_extrusion_get, METH_O, NULL},
	 { "new_Dwg_Entity_SOLID", _wrap_new_Dwg_Entity_SOLID, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SOLID", _wrap_delete_Dwg_Entity_SOLID, METH_O, NULL},
	 { "Dwg_Entity_SOLID_swigregister", Dwg_Entity_SOLID_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SOLID_swiginit", Dwg_Entity_SOLID_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_parent_set", _wrap_Dwg_Entity_TRACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_parent_get", _wrap_Dwg_Entity_TRACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_thickness_set", _wrap_Dwg_Entity_TRACE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_thickness_get", _wrap_Dwg_Entity_TRACE_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_elevation_set", _wrap_Dwg_Entity_TRACE_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_elevation_get", _wrap_Dwg_Entity_TRACE_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_corner1_set", _wrap_Dwg_Entity_TRACE_corner1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_corner1_get", _wrap_Dwg_Entity_TRACE_corner1_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_corner2_set", _wrap_Dwg_Entity_TRACE_corner2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_corner2_get", _wrap_Dwg_Entity_TRACE_corner2_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_corner3_set", _wrap_Dwg_Entity_TRACE_corner3_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_corner3_get", _wrap_Dwg_Entity_TRACE_corner3_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_corner4_set", _wrap_Dwg_Entity_TRACE_corner4_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_corner4_get", _wrap_Dwg_Entity_TRACE_corner4_get, METH_O, NULL},
	 { "Dwg_Entity_TRACE_extrusion_set", _wrap_Dwg_Entity_TRACE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TRACE_extrusion_get", _wrap_Dwg_Entity_TRACE_extrusion_get, METH_O, NULL},
	 { "new_Dwg_Entity_TRACE", _wrap_new_Dwg_Entity_TRACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_TRACE", _wrap_delete_Dwg_Entity_TRACE, METH_O, NULL},
	 { "Dwg_Entity_TRACE_swigregister", Dwg_Entity_TRACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_TRACE_swiginit", Dwg_Entity_TRACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_parent_set", _wrap_Dwg_Entity_SHAPE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_parent_get", _wrap_Dwg_Entity_SHAPE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_ins_pt_set", _wrap_Dwg_Entity_SHAPE_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_ins_pt_get", _wrap_Dwg_Entity_SHAPE_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_scale_set", _wrap_Dwg_Entity_SHAPE_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_scale_get", _wrap_Dwg_Entity_SHAPE_scale_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_rotation_set", _wrap_Dwg_Entity_SHAPE_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_rotation_get", _wrap_Dwg_Entity_SHAPE_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_width_factor_set", _wrap_Dwg_Entity_SHAPE_width_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_width_factor_get", _wrap_Dwg_Entity_SHAPE_width_factor_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_oblique_angle_set", _wrap_Dwg_Entity_SHAPE_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_oblique_angle_get", _wrap_Dwg_Entity_SHAPE_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_thickness_set", _wrap_Dwg_Entity_SHAPE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_thickness_get", _wrap_Dwg_Entity_SHAPE_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_style_id_set", _wrap_Dwg_Entity_SHAPE_style_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_style_id_get", _wrap_Dwg_Entity_SHAPE_style_id_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_extrusion_set", _wrap_Dwg_Entity_SHAPE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_extrusion_get", _wrap_Dwg_Entity_SHAPE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_style_set", _wrap_Dwg_Entity_SHAPE_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SHAPE_style_get", _wrap_Dwg_Entity_SHAPE_style_get, METH_O, NULL},
	 { "new_Dwg_Entity_SHAPE", _wrap_new_Dwg_Entity_SHAPE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SHAPE", _wrap_delete_Dwg_Entity_SHAPE, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_swigregister", Dwg_Entity_SHAPE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SHAPE_swiginit", Dwg_Entity_SHAPE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_parent_set", _wrap_Dwg_Entity_VIEWPORT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_parent_get", _wrap_Dwg_Entity_VIEWPORT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_center_set", _wrap_Dwg_Entity_VIEWPORT_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_center_get", _wrap_Dwg_Entity_VIEWPORT_center_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_width_set", _wrap_Dwg_Entity_VIEWPORT_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_width_get", _wrap_Dwg_Entity_VIEWPORT_width_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_height_set", _wrap_Dwg_Entity_VIEWPORT_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_height_get", _wrap_Dwg_Entity_VIEWPORT_height_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_on_off_set", _wrap_Dwg_Entity_VIEWPORT_on_off_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_on_off_get", _wrap_Dwg_Entity_VIEWPORT_on_off_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_id_set", _wrap_Dwg_Entity_VIEWPORT_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_id_get", _wrap_Dwg_Entity_VIEWPORT_id_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_view_target_set", _wrap_Dwg_Entity_VIEWPORT_view_target_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_view_target_get", _wrap_Dwg_Entity_VIEWPORT_view_target_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWDIR_set", _wrap_Dwg_Entity_VIEWPORT_VIEWDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWDIR_get", _wrap_Dwg_Entity_VIEWPORT_VIEWDIR_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_twist_angle_set", _wrap_Dwg_Entity_VIEWPORT_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_twist_angle_get", _wrap_Dwg_Entity_VIEWPORT_twist_angle_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWSIZE_set", _wrap_Dwg_Entity_VIEWPORT_VIEWSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWSIZE_get", _wrap_Dwg_Entity_VIEWPORT_VIEWSIZE_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_lens_length_set", _wrap_Dwg_Entity_VIEWPORT_lens_length_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_lens_length_get", _wrap_Dwg_Entity_VIEWPORT_lens_length_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_front_clip_z_set", _wrap_Dwg_Entity_VIEWPORT_front_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_front_clip_z_get", _wrap_Dwg_Entity_VIEWPORT_front_clip_z_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_back_clip_z_set", _wrap_Dwg_Entity_VIEWPORT_back_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_back_clip_z_get", _wrap_Dwg_Entity_VIEWPORT_back_clip_z_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPANG_set", _wrap_Dwg_Entity_VIEWPORT_SNAPANG_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPANG_get", _wrap_Dwg_Entity_VIEWPORT_SNAPANG_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWCTR_set", _wrap_Dwg_Entity_VIEWPORT_VIEWCTR_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_VIEWCTR_get", _wrap_Dwg_Entity_VIEWPORT_VIEWCTR_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPBASE_set", _wrap_Dwg_Entity_VIEWPORT_SNAPBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPBASE_get", _wrap_Dwg_Entity_VIEWPORT_SNAPBASE_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPUNIT_set", _wrap_Dwg_Entity_VIEWPORT_SNAPUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_SNAPUNIT_get", _wrap_Dwg_Entity_VIEWPORT_SNAPUNIT_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_GRIDUNIT_set", _wrap_Dwg_Entity_VIEWPORT_GRIDUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_GRIDUNIT_get", _wrap_Dwg_Entity_VIEWPORT_GRIDUNIT_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_circle_zoom_set", _wrap_Dwg_Entity_VIEWPORT_circle_zoom_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_circle_zoom_get", _wrap_Dwg_Entity_VIEWPORT_circle_zoom_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_grid_major_set", _wrap_Dwg_Entity_VIEWPORT_grid_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_grid_major_get", _wrap_Dwg_Entity_VIEWPORT_grid_major_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_num_frozen_layers_set", _wrap_Dwg_Entity_VIEWPORT_num_frozen_layers_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_num_frozen_layers_get", _wrap_Dwg_Entity_VIEWPORT_num_frozen_layers_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_status_flag_set", _wrap_Dwg_Entity_VIEWPORT_status_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_status_flag_get", _wrap_Dwg_Entity_VIEWPORT_status_flag_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_style_sheet_set", _wrap_Dwg_Entity_VIEWPORT_style_sheet_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_style_sheet_get", _wrap_Dwg_Entity_VIEWPORT_style_sheet_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_render_mode_set", _wrap_Dwg_Entity_VIEWPORT_render_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_render_mode_get", _wrap_Dwg_Entity_VIEWPORT_render_mode_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ucs_at_origin_set", _wrap_Dwg_Entity_VIEWPORT_ucs_at_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ucs_at_origin_get", _wrap_Dwg_Entity_VIEWPORT_ucs_at_origin_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_UCSVP_set", _wrap_Dwg_Entity_VIEWPORT_UCSVP_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_UCSVP_get", _wrap_Dwg_Entity_VIEWPORT_UCSVP_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsorg_set", _wrap_Dwg_Entity_VIEWPORT_ucsorg_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsorg_get", _wrap_Dwg_Entity_VIEWPORT_ucsorg_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsxdir_set", _wrap_Dwg_Entity_VIEWPORT_ucsxdir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsxdir_get", _wrap_Dwg_Entity_VIEWPORT_ucsxdir_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsydir_set", _wrap_Dwg_Entity_VIEWPORT_ucsydir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ucsydir_get", _wrap_Dwg_Entity_VIEWPORT_ucsydir_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ucs_elevation_set", _wrap_Dwg_Entity_VIEWPORT_ucs_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ucs_elevation_get", _wrap_Dwg_Entity_VIEWPORT_ucs_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set", _wrap_Dwg_Entity_VIEWPORT_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_UCSORTHOVIEW_get", _wrap_Dwg_Entity_VIEWPORT_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_shadeplot_mode_set", _wrap_Dwg_Entity_VIEWPORT_shadeplot_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_shadeplot_mode_get", _wrap_Dwg_Entity_VIEWPORT_shadeplot_mode_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_use_default_lights_set", _wrap_Dwg_Entity_VIEWPORT_use_default_lights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_use_default_lights_get", _wrap_Dwg_Entity_VIEWPORT_use_default_lights_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_default_lighting_type_set", _wrap_Dwg_Entity_VIEWPORT_default_lighting_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_default_lighting_type_get", _wrap_Dwg_Entity_VIEWPORT_default_lighting_type_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_brightness_set", _wrap_Dwg_Entity_VIEWPORT_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_brightness_get", _wrap_Dwg_Entity_VIEWPORT_brightness_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_contrast_set", _wrap_Dwg_Entity_VIEWPORT_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_contrast_get", _wrap_Dwg_Entity_VIEWPORT_contrast_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_ambient_color_set", _wrap_Dwg_Entity_VIEWPORT_ambient_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_ambient_color_get", _wrap_Dwg_Entity_VIEWPORT_ambient_color_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_vport_entity_header_set", _wrap_Dwg_Entity_VIEWPORT_vport_entity_header_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_vport_entity_header_get", _wrap_Dwg_Entity_VIEWPORT_vport_entity_header_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_frozen_layers_set", _wrap_Dwg_Entity_VIEWPORT_frozen_layers_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_frozen_layers_get", _wrap_Dwg_Entity_VIEWPORT_frozen_layers_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_clip_boundary_set", _wrap_Dwg_Entity_VIEWPORT_clip_boundary_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_clip_boundary_get", _wrap_Dwg_Entity_VIEWPORT_clip_boundary_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_named_ucs_set", _wrap_Dwg_Entity_VIEWPORT_named_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_named_ucs_get", _wrap_Dwg_Entity_VIEWPORT_named_ucs_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_base_ucs_set", _wrap_Dwg_Entity_VIEWPORT_base_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_base_ucs_get", _wrap_Dwg_Entity_VIEWPORT_base_ucs_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_background_set", _wrap_Dwg_Entity_VIEWPORT_background_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_background_get", _wrap_Dwg_Entity_VIEWPORT_background_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_visualstyle_set", _wrap_Dwg_Entity_VIEWPORT_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_visualstyle_get", _wrap_Dwg_Entity_VIEWPORT_visualstyle_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_shadeplot_set", _wrap_Dwg_Entity_VIEWPORT_shadeplot_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_shadeplot_get", _wrap_Dwg_Entity_VIEWPORT_shadeplot_get, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_sun_set", _wrap_Dwg_Entity_VIEWPORT_sun_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VIEWPORT_sun_get", _wrap_Dwg_Entity_VIEWPORT_sun_get, METH_O, NULL},
	 { "new_Dwg_Entity_VIEWPORT", _wrap_new_Dwg_Entity_VIEWPORT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VIEWPORT", _wrap_delete_Dwg_Entity_VIEWPORT, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_swigregister", Dwg_Entity_VIEWPORT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VIEWPORT_swiginit", Dwg_Entity_VIEWPORT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_parent_set", _wrap_Dwg_Entity_ELLIPSE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_parent_get", _wrap_Dwg_Entity_ELLIPSE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_center_set", _wrap_Dwg_Entity_ELLIPSE_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_center_get", _wrap_Dwg_Entity_ELLIPSE_center_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_sm_axis_set", _wrap_Dwg_Entity_ELLIPSE_sm_axis_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_sm_axis_get", _wrap_Dwg_Entity_ELLIPSE_sm_axis_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_extrusion_set", _wrap_Dwg_Entity_ELLIPSE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_extrusion_get", _wrap_Dwg_Entity_ELLIPSE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_axis_ratio_set", _wrap_Dwg_Entity_ELLIPSE_axis_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_axis_ratio_get", _wrap_Dwg_Entity_ELLIPSE_axis_ratio_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_start_angle_set", _wrap_Dwg_Entity_ELLIPSE_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_start_angle_get", _wrap_Dwg_Entity_ELLIPSE_start_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_end_angle_set", _wrap_Dwg_Entity_ELLIPSE_end_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ELLIPSE_end_angle_get", _wrap_Dwg_Entity_ELLIPSE_end_angle_get, METH_O, NULL},
	 { "new_Dwg_Entity_ELLIPSE", _wrap_new_Dwg_Entity_ELLIPSE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ELLIPSE", _wrap_delete_Dwg_Entity_ELLIPSE, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_swigregister", Dwg_Entity_ELLIPSE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ELLIPSE_swiginit", Dwg_Entity_ELLIPSE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_parent_set", _wrap_Dwg_SPLINE_control_point_parent_set, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_parent_get", _wrap_Dwg_SPLINE_control_point_parent_get, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_x_set", _wrap_Dwg_SPLINE_control_point_x_set, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_x_get", _wrap_Dwg_SPLINE_control_point_x_get, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_y_set", _wrap_Dwg_SPLINE_control_point_y_set, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_y_get", _wrap_Dwg_SPLINE_control_point_y_get, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_z_set", _wrap_Dwg_SPLINE_control_point_z_set, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_z_get", _wrap_Dwg_SPLINE_control_point_z_get, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_w_set", _wrap_Dwg_SPLINE_control_point_w_set, METH_VARARGS, NULL},
	 { "Dwg_SPLINE_control_point_w_get", _wrap_Dwg_SPLINE_control_point_w_get, METH_O, NULL},
	 { "new_Dwg_SPLINE_control_point", _wrap_new_Dwg_SPLINE_control_point, METH_NOARGS, NULL},
	 { "delete_Dwg_SPLINE_control_point", _wrap_delete_Dwg_SPLINE_control_point, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_swigregister", Dwg_SPLINE_control_point_swigregister, METH_O, NULL},
	 { "Dwg_SPLINE_control_point_swiginit", Dwg_SPLINE_control_point_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_parent_set", _wrap_Dwg_Entity_SPLINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_parent_get", _wrap_Dwg_Entity_SPLINE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_flag_set", _wrap_Dwg_Entity_SPLINE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_flag_get", _wrap_Dwg_Entity_SPLINE_flag_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_scenario_set", _wrap_Dwg_Entity_SPLINE_scenario_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_scenario_get", _wrap_Dwg_Entity_SPLINE_scenario_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_degree_set", _wrap_Dwg_Entity_SPLINE_degree_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_degree_get", _wrap_Dwg_Entity_SPLINE_degree_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_splineflags_set", _wrap_Dwg_Entity_SPLINE_splineflags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_splineflags_get", _wrap_Dwg_Entity_SPLINE_splineflags_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_knotparam_set", _wrap_Dwg_Entity_SPLINE_knotparam_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_knotparam_get", _wrap_Dwg_Entity_SPLINE_knotparam_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_fit_tol_set", _wrap_Dwg_Entity_SPLINE_fit_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_fit_tol_get", _wrap_Dwg_Entity_SPLINE_fit_tol_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_beg_tan_vec_set", _wrap_Dwg_Entity_SPLINE_beg_tan_vec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_beg_tan_vec_get", _wrap_Dwg_Entity_SPLINE_beg_tan_vec_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_end_tan_vec_set", _wrap_Dwg_Entity_SPLINE_end_tan_vec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_end_tan_vec_get", _wrap_Dwg_Entity_SPLINE_end_tan_vec_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_closed_b_set", _wrap_Dwg_Entity_SPLINE_closed_b_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_closed_b_get", _wrap_Dwg_Entity_SPLINE_closed_b_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_periodic_set", _wrap_Dwg_Entity_SPLINE_periodic_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_periodic_get", _wrap_Dwg_Entity_SPLINE_periodic_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_rational_set", _wrap_Dwg_Entity_SPLINE_rational_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_rational_get", _wrap_Dwg_Entity_SPLINE_rational_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_weighted_set", _wrap_Dwg_Entity_SPLINE_weighted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_weighted_get", _wrap_Dwg_Entity_SPLINE_weighted_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_knot_tol_set", _wrap_Dwg_Entity_SPLINE_knot_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_knot_tol_get", _wrap_Dwg_Entity_SPLINE_knot_tol_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_ctrl_tol_set", _wrap_Dwg_Entity_SPLINE_ctrl_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_ctrl_tol_get", _wrap_Dwg_Entity_SPLINE_ctrl_tol_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_num_fit_pts_set", _wrap_Dwg_Entity_SPLINE_num_fit_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_num_fit_pts_get", _wrap_Dwg_Entity_SPLINE_num_fit_pts_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_fit_pts_set", _wrap_Dwg_Entity_SPLINE_fit_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_fit_pts_get", _wrap_Dwg_Entity_SPLINE_fit_pts_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_num_knots_set", _wrap_Dwg_Entity_SPLINE_num_knots_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_num_knots_get", _wrap_Dwg_Entity_SPLINE_num_knots_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_knots_set", _wrap_Dwg_Entity_SPLINE_knots_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_knots_get", _wrap_Dwg_Entity_SPLINE_knots_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_num_ctrl_pts_set", _wrap_Dwg_Entity_SPLINE_num_ctrl_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_num_ctrl_pts_get", _wrap_Dwg_Entity_SPLINE_num_ctrl_pts_get, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_ctrl_pts_set", _wrap_Dwg_Entity_SPLINE_ctrl_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SPLINE_ctrl_pts_get", _wrap_Dwg_Entity_SPLINE_ctrl_pts_get, METH_O, NULL},
	 { "new_Dwg_Entity_SPLINE", _wrap_new_Dwg_Entity_SPLINE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SPLINE", _wrap_delete_Dwg_Entity_SPLINE, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_swigregister", Dwg_Entity_SPLINE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SPLINE_swiginit", Dwg_Entity_SPLINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_parent_set", _wrap_Dwg_3DSOLID_wire_parent_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_parent_get", _wrap_Dwg_3DSOLID_wire_parent_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_type_set", _wrap_Dwg_3DSOLID_wire_type_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_type_get", _wrap_Dwg_3DSOLID_wire_type_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_selection_marker_set", _wrap_Dwg_3DSOLID_wire_selection_marker_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_selection_marker_get", _wrap_Dwg_3DSOLID_wire_selection_marker_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_color_set", _wrap_Dwg_3DSOLID_wire_color_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_color_get", _wrap_Dwg_3DSOLID_wire_color_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_acis_index_set", _wrap_Dwg_3DSOLID_wire_acis_index_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_acis_index_get", _wrap_Dwg_3DSOLID_wire_acis_index_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_num_points_set", _wrap_Dwg_3DSOLID_wire_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_num_points_get", _wrap_Dwg_3DSOLID_wire_num_points_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_points_set", _wrap_Dwg_3DSOLID_wire_points_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_points_get", _wrap_Dwg_3DSOLID_wire_points_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_transform_present_set", _wrap_Dwg_3DSOLID_wire_transform_present_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_transform_present_get", _wrap_Dwg_3DSOLID_wire_transform_present_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_axis_x_set", _wrap_Dwg_3DSOLID_wire_axis_x_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_axis_x_get", _wrap_Dwg_3DSOLID_wire_axis_x_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_axis_y_set", _wrap_Dwg_3DSOLID_wire_axis_y_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_axis_y_get", _wrap_Dwg_3DSOLID_wire_axis_y_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_axis_z_set", _wrap_Dwg_3DSOLID_wire_axis_z_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_axis_z_get", _wrap_Dwg_3DSOLID_wire_axis_z_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_translation_set", _wrap_Dwg_3DSOLID_wire_translation_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_translation_get", _wrap_Dwg_3DSOLID_wire_translation_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_scale_set", _wrap_Dwg_3DSOLID_wire_scale_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_scale_get", _wrap_Dwg_3DSOLID_wire_scale_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_has_rotation_set", _wrap_Dwg_3DSOLID_wire_has_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_has_rotation_get", _wrap_Dwg_3DSOLID_wire_has_rotation_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_has_reflection_set", _wrap_Dwg_3DSOLID_wire_has_reflection_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_has_reflection_get", _wrap_Dwg_3DSOLID_wire_has_reflection_get, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_has_shear_set", _wrap_Dwg_3DSOLID_wire_has_shear_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_wire_has_shear_get", _wrap_Dwg_3DSOLID_wire_has_shear_get, METH_O, NULL},
	 { "new_Dwg_3DSOLID_wire", _wrap_new_Dwg_3DSOLID_wire, METH_NOARGS, NULL},
	 { "delete_Dwg_3DSOLID_wire", _wrap_delete_Dwg_3DSOLID_wire, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_swigregister", Dwg_3DSOLID_wire_swigregister, METH_O, NULL},
	 { "Dwg_3DSOLID_wire_swiginit", Dwg_3DSOLID_wire_swiginit, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_parent_set", _wrap_Dwg_3DSOLID_silhouette_parent_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_parent_get", _wrap_Dwg_3DSOLID_silhouette_parent_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_id_set", _wrap_Dwg_3DSOLID_silhouette_vp_id_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_id_get", _wrap_Dwg_3DSOLID_silhouette_vp_id_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_target_set", _wrap_Dwg_3DSOLID_silhouette_vp_target_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_target_get", _wrap_Dwg_3DSOLID_silhouette_vp_target_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_dir_from_target_set", _wrap_Dwg_3DSOLID_silhouette_vp_dir_from_target_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_dir_from_target_get", _wrap_Dwg_3DSOLID_silhouette_vp_dir_from_target_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_up_dir_set", _wrap_Dwg_3DSOLID_silhouette_vp_up_dir_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_up_dir_get", _wrap_Dwg_3DSOLID_silhouette_vp_up_dir_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_perspective_set", _wrap_Dwg_3DSOLID_silhouette_vp_perspective_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_vp_perspective_get", _wrap_Dwg_3DSOLID_silhouette_vp_perspective_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_has_wires_set", _wrap_Dwg_3DSOLID_silhouette_has_wires_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_has_wires_get", _wrap_Dwg_3DSOLID_silhouette_has_wires_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_num_wires_set", _wrap_Dwg_3DSOLID_silhouette_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_num_wires_get", _wrap_Dwg_3DSOLID_silhouette_num_wires_get, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_wires_set", _wrap_Dwg_3DSOLID_silhouette_wires_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_silhouette_wires_get", _wrap_Dwg_3DSOLID_silhouette_wires_get, METH_O, NULL},
	 { "new_Dwg_3DSOLID_silhouette", _wrap_new_Dwg_3DSOLID_silhouette, METH_NOARGS, NULL},
	 { "delete_Dwg_3DSOLID_silhouette", _wrap_delete_Dwg_3DSOLID_silhouette, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_swigregister", Dwg_3DSOLID_silhouette_swigregister, METH_O, NULL},
	 { "Dwg_3DSOLID_silhouette_swiginit", Dwg_3DSOLID_silhouette_swiginit, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_material_parent_set", _wrap_Dwg_3DSOLID_material_parent_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_material_parent_get", _wrap_Dwg_3DSOLID_material_parent_get, METH_O, NULL},
	 { "Dwg_3DSOLID_material_array_index_set", _wrap_Dwg_3DSOLID_material_array_index_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_material_array_index_get", _wrap_Dwg_3DSOLID_material_array_index_get, METH_O, NULL},
	 { "Dwg_3DSOLID_material_mat_absref_set", _wrap_Dwg_3DSOLID_material_mat_absref_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_material_mat_absref_get", _wrap_Dwg_3DSOLID_material_mat_absref_get, METH_O, NULL},
	 { "Dwg_3DSOLID_material_material_handle_set", _wrap_Dwg_3DSOLID_material_material_handle_set, METH_VARARGS, NULL},
	 { "Dwg_3DSOLID_material_material_handle_get", _wrap_Dwg_3DSOLID_material_material_handle_get, METH_O, NULL},
	 { "new_Dwg_3DSOLID_material", _wrap_new_Dwg_3DSOLID_material, METH_NOARGS, NULL},
	 { "delete_Dwg_3DSOLID_material", _wrap_delete_Dwg_3DSOLID_material, METH_O, NULL},
	 { "Dwg_3DSOLID_material_swigregister", Dwg_3DSOLID_material_swigregister, METH_O, NULL},
	 { "Dwg_3DSOLID_material_swiginit", Dwg_3DSOLID_material_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_parent_set", _wrap_Dwg_Entity__3DSOLID_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_parent_get", _wrap_Dwg_Entity__3DSOLID_parent_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty_set", _wrap_Dwg_Entity__3DSOLID_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty_get", _wrap_Dwg_Entity__3DSOLID_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_unknown_set", _wrap_Dwg_Entity__3DSOLID_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_unknown_get", _wrap_Dwg_Entity__3DSOLID_unknown_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_version_set", _wrap_Dwg_Entity__3DSOLID_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_version_get", _wrap_Dwg_Entity__3DSOLID_version_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_num_blocks_set", _wrap_Dwg_Entity__3DSOLID_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_num_blocks_get", _wrap_Dwg_Entity__3DSOLID_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_block_size_set", _wrap_Dwg_Entity__3DSOLID_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_block_size_get", _wrap_Dwg_Entity__3DSOLID_block_size_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_encr_sat_data_set", _wrap_Dwg_Entity__3DSOLID_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_encr_sat_data_get", _wrap_Dwg_Entity__3DSOLID_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_sab_size_set", _wrap_Dwg_Entity__3DSOLID_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_sab_size_get", _wrap_Dwg_Entity__3DSOLID_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_acis_data_set", _wrap_Dwg_Entity__3DSOLID_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_acis_data_get", _wrap_Dwg_Entity__3DSOLID_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_wireframe_data_present_set", _wrap_Dwg_Entity__3DSOLID_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_wireframe_data_present_get", _wrap_Dwg_Entity__3DSOLID_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_point_present_set", _wrap_Dwg_Entity__3DSOLID_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_point_present_get", _wrap_Dwg_Entity__3DSOLID_point_present_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_point_set", _wrap_Dwg_Entity__3DSOLID_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_point_get", _wrap_Dwg_Entity__3DSOLID_point_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_isolines_set", _wrap_Dwg_Entity__3DSOLID_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_isolines_get", _wrap_Dwg_Entity__3DSOLID_isolines_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_isoline_present_set", _wrap_Dwg_Entity__3DSOLID_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_isoline_present_get", _wrap_Dwg_Entity__3DSOLID_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_num_wires_set", _wrap_Dwg_Entity__3DSOLID_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_num_wires_get", _wrap_Dwg_Entity__3DSOLID_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_wires_set", _wrap_Dwg_Entity__3DSOLID_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_wires_get", _wrap_Dwg_Entity__3DSOLID_wires_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_num_silhouettes_set", _wrap_Dwg_Entity__3DSOLID_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_num_silhouettes_get", _wrap_Dwg_Entity__3DSOLID_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_silhouettes_set", _wrap_Dwg_Entity__3DSOLID_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_silhouettes_get", _wrap_Dwg_Entity__3DSOLID_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID__dxf_sab_converted_set", _wrap_Dwg_Entity__3DSOLID__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID__dxf_sab_converted_get", _wrap_Dwg_Entity__3DSOLID__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty2_set", _wrap_Dwg_Entity__3DSOLID_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty2_get", _wrap_Dwg_Entity__3DSOLID_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_extra_acis_data_set", _wrap_Dwg_Entity__3DSOLID_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_extra_acis_data_get", _wrap_Dwg_Entity__3DSOLID_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_num_materials_set", _wrap_Dwg_Entity__3DSOLID_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_num_materials_get", _wrap_Dwg_Entity__3DSOLID_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_materials_set", _wrap_Dwg_Entity__3DSOLID_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_materials_get", _wrap_Dwg_Entity__3DSOLID_materials_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_revision_guid_set", _wrap_Dwg_Entity__3DSOLID_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_revision_guid_get", _wrap_Dwg_Entity__3DSOLID_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_revision_major_set", _wrap_Dwg_Entity__3DSOLID_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_revision_major_get", _wrap_Dwg_Entity__3DSOLID_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_revision_minor1_set", _wrap_Dwg_Entity__3DSOLID_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_revision_minor1_get", _wrap_Dwg_Entity__3DSOLID_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_revision_minor2_set", _wrap_Dwg_Entity__3DSOLID_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_revision_minor2_get", _wrap_Dwg_Entity__3DSOLID_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_revision_bytes_set", _wrap_Dwg_Entity__3DSOLID_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_revision_bytes_get", _wrap_Dwg_Entity__3DSOLID_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_end_marker_set", _wrap_Dwg_Entity__3DSOLID_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_end_marker_get", _wrap_Dwg_Entity__3DSOLID_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_history_id_set", _wrap_Dwg_Entity__3DSOLID_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_history_id_get", _wrap_Dwg_Entity__3DSOLID_history_id_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_has_revision_guid_set", _wrap_Dwg_Entity__3DSOLID_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_has_revision_guid_get", _wrap_Dwg_Entity__3DSOLID_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty_bit_set", _wrap_Dwg_Entity__3DSOLID_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DSOLID_acis_empty_bit_get", _wrap_Dwg_Entity__3DSOLID_acis_empty_bit_get, METH_O, NULL},
	 { "new_Dwg_Entity__3DSOLID", _wrap_new_Dwg_Entity__3DSOLID, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity__3DSOLID", _wrap_delete_Dwg_Entity__3DSOLID, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_swigregister", Dwg_Entity__3DSOLID_swigregister, METH_O, NULL},
	 { "Dwg_Entity__3DSOLID_swiginit", Dwg_Entity__3DSOLID_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_RAY_parent_set", _wrap_Dwg_Entity_RAY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RAY_parent_get", _wrap_Dwg_Entity_RAY_parent_get, METH_O, NULL},
	 { "Dwg_Entity_RAY_point_set", _wrap_Dwg_Entity_RAY_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RAY_point_get", _wrap_Dwg_Entity_RAY_point_get, METH_O, NULL},
	 { "Dwg_Entity_RAY_vector_set", _wrap_Dwg_Entity_RAY_vector_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RAY_vector_get", _wrap_Dwg_Entity_RAY_vector_get, METH_O, NULL},
	 { "new_Dwg_Entity_RAY", _wrap_new_Dwg_Entity_RAY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_RAY", _wrap_delete_Dwg_Entity_RAY, METH_O, NULL},
	 { "Dwg_Entity_RAY_swigregister", Dwg_Entity_RAY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_RAY_swiginit", Dwg_Entity_RAY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_parent_set", _wrap_Dwg_Object_DICTIONARY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_parent_get", _wrap_Dwg_Object_DICTIONARY_parent_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_numitems_set", _wrap_Dwg_Object_DICTIONARY_numitems_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_numitems_get", _wrap_Dwg_Object_DICTIONARY_numitems_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_is_hardowner_set", _wrap_Dwg_Object_DICTIONARY_is_hardowner_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_is_hardowner_get", _wrap_Dwg_Object_DICTIONARY_is_hardowner_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_cloning_set", _wrap_Dwg_Object_DICTIONARY_cloning_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_cloning_get", _wrap_Dwg_Object_DICTIONARY_cloning_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_texts_set", _wrap_Dwg_Object_DICTIONARY_texts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_texts_get", _wrap_Dwg_Object_DICTIONARY_texts_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_itemhandles_set", _wrap_Dwg_Object_DICTIONARY_itemhandles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARY_itemhandles_get", _wrap_Dwg_Object_DICTIONARY_itemhandles_get, METH_O, NULL},
	 { "new_Dwg_Object_DICTIONARY", _wrap_new_Dwg_Object_DICTIONARY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DICTIONARY", _wrap_delete_Dwg_Object_DICTIONARY, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_swigregister", Dwg_Object_DICTIONARY_swigregister, METH_O, NULL},
	 { "Dwg_Object_DICTIONARY_swiginit", Dwg_Object_DICTIONARY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_parent_set", _wrap_Dwg_Object_DICTIONARYWDFLT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_parent_get", _wrap_Dwg_Object_DICTIONARYWDFLT_parent_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_numitems_set", _wrap_Dwg_Object_DICTIONARYWDFLT_numitems_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_numitems_get", _wrap_Dwg_Object_DICTIONARYWDFLT_numitems_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_is_hardowner_set", _wrap_Dwg_Object_DICTIONARYWDFLT_is_hardowner_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_is_hardowner_get", _wrap_Dwg_Object_DICTIONARYWDFLT_is_hardowner_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_cloning_set", _wrap_Dwg_Object_DICTIONARYWDFLT_cloning_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_cloning_get", _wrap_Dwg_Object_DICTIONARYWDFLT_cloning_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_texts_set", _wrap_Dwg_Object_DICTIONARYWDFLT_texts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_texts_get", _wrap_Dwg_Object_DICTIONARYWDFLT_texts_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_itemhandles_set", _wrap_Dwg_Object_DICTIONARYWDFLT_itemhandles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_itemhandles_get", _wrap_Dwg_Object_DICTIONARYWDFLT_itemhandles_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_defaultid_set", _wrap_Dwg_Object_DICTIONARYWDFLT_defaultid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_defaultid_get", _wrap_Dwg_Object_DICTIONARYWDFLT_defaultid_get, METH_O, NULL},
	 { "new_Dwg_Object_DICTIONARYWDFLT", _wrap_new_Dwg_Object_DICTIONARYWDFLT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DICTIONARYWDFLT", _wrap_delete_Dwg_Object_DICTIONARYWDFLT, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_swigregister", Dwg_Object_DICTIONARYWDFLT_swigregister, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYWDFLT_swiginit", Dwg_Object_DICTIONARYWDFLT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_parent_set", _wrap_Dwg_Entity_OLEFRAME_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_parent_get", _wrap_Dwg_Entity_OLEFRAME_parent_get, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_flag_set", _wrap_Dwg_Entity_OLEFRAME_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_flag_get", _wrap_Dwg_Entity_OLEFRAME_flag_get, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_mode_set", _wrap_Dwg_Entity_OLEFRAME_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_mode_get", _wrap_Dwg_Entity_OLEFRAME_mode_get, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_data_size_set", _wrap_Dwg_Entity_OLEFRAME_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_data_size_get", _wrap_Dwg_Entity_OLEFRAME_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_data_set", _wrap_Dwg_Entity_OLEFRAME_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLEFRAME_data_get", _wrap_Dwg_Entity_OLEFRAME_data_get, METH_O, NULL},
	 { "new_Dwg_Entity_OLEFRAME", _wrap_new_Dwg_Entity_OLEFRAME, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_OLEFRAME", _wrap_delete_Dwg_Entity_OLEFRAME, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_swigregister", Dwg_Entity_OLEFRAME_swigregister, METH_O, NULL},
	 { "Dwg_Entity_OLEFRAME_swiginit", Dwg_Entity_OLEFRAME_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_parent_set", _wrap_Dwg_Entity_MTEXT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_parent_get", _wrap_Dwg_Entity_MTEXT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_ins_pt_set", _wrap_Dwg_Entity_MTEXT_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_ins_pt_get", _wrap_Dwg_Entity_MTEXT_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_extrusion_set", _wrap_Dwg_Entity_MTEXT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_extrusion_get", _wrap_Dwg_Entity_MTEXT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_x_axis_dir_set", _wrap_Dwg_Entity_MTEXT_x_axis_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_x_axis_dir_get", _wrap_Dwg_Entity_MTEXT_x_axis_dir_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_rect_height_set", _wrap_Dwg_Entity_MTEXT_rect_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_rect_height_get", _wrap_Dwg_Entity_MTEXT_rect_height_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_rect_width_set", _wrap_Dwg_Entity_MTEXT_rect_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_rect_width_get", _wrap_Dwg_Entity_MTEXT_rect_width_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_text_height_set", _wrap_Dwg_Entity_MTEXT_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_text_height_get", _wrap_Dwg_Entity_MTEXT_text_height_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_attachment_set", _wrap_Dwg_Entity_MTEXT_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_attachment_get", _wrap_Dwg_Entity_MTEXT_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_flow_dir_set", _wrap_Dwg_Entity_MTEXT_flow_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_flow_dir_get", _wrap_Dwg_Entity_MTEXT_flow_dir_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_extents_width_set", _wrap_Dwg_Entity_MTEXT_extents_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_extents_width_get", _wrap_Dwg_Entity_MTEXT_extents_width_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_extents_height_set", _wrap_Dwg_Entity_MTEXT_extents_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_extents_height_get", _wrap_Dwg_Entity_MTEXT_extents_height_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_text_set", _wrap_Dwg_Entity_MTEXT_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_text_get", _wrap_Dwg_Entity_MTEXT_text_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_style_set", _wrap_Dwg_Entity_MTEXT_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_style_get", _wrap_Dwg_Entity_MTEXT_style_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_linespace_style_set", _wrap_Dwg_Entity_MTEXT_linespace_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_linespace_style_get", _wrap_Dwg_Entity_MTEXT_linespace_style_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_linespace_factor_set", _wrap_Dwg_Entity_MTEXT_linespace_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_linespace_factor_get", _wrap_Dwg_Entity_MTEXT_linespace_factor_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_unknown_b0_set", _wrap_Dwg_Entity_MTEXT_unknown_b0_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_unknown_b0_get", _wrap_Dwg_Entity_MTEXT_unknown_b0_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_flag_set", _wrap_Dwg_Entity_MTEXT_bg_fill_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_flag_get", _wrap_Dwg_Entity_MTEXT_bg_fill_flag_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_scale_set", _wrap_Dwg_Entity_MTEXT_bg_fill_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_scale_get", _wrap_Dwg_Entity_MTEXT_bg_fill_scale_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_color_set", _wrap_Dwg_Entity_MTEXT_bg_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_color_get", _wrap_Dwg_Entity_MTEXT_bg_fill_color_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_trans_set", _wrap_Dwg_Entity_MTEXT_bg_fill_trans_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_bg_fill_trans_get", _wrap_Dwg_Entity_MTEXT_bg_fill_trans_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_is_not_annotative_set", _wrap_Dwg_Entity_MTEXT_is_not_annotative_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_is_not_annotative_get", _wrap_Dwg_Entity_MTEXT_is_not_annotative_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_class_version_set", _wrap_Dwg_Entity_MTEXT_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_class_version_get", _wrap_Dwg_Entity_MTEXT_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_default_flag_set", _wrap_Dwg_Entity_MTEXT_default_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_default_flag_get", _wrap_Dwg_Entity_MTEXT_default_flag_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_appid_set", _wrap_Dwg_Entity_MTEXT_appid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_appid_get", _wrap_Dwg_Entity_MTEXT_appid_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_ignore_attachment_set", _wrap_Dwg_Entity_MTEXT_ignore_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_ignore_attachment_get", _wrap_Dwg_Entity_MTEXT_ignore_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_column_type_set", _wrap_Dwg_Entity_MTEXT_column_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_column_type_get", _wrap_Dwg_Entity_MTEXT_column_type_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_numfragments_set", _wrap_Dwg_Entity_MTEXT_numfragments_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_numfragments_get", _wrap_Dwg_Entity_MTEXT_numfragments_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_column_width_set", _wrap_Dwg_Entity_MTEXT_column_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_column_width_get", _wrap_Dwg_Entity_MTEXT_column_width_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_gutter_set", _wrap_Dwg_Entity_MTEXT_gutter_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_gutter_get", _wrap_Dwg_Entity_MTEXT_gutter_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_auto_height_set", _wrap_Dwg_Entity_MTEXT_auto_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_auto_height_get", _wrap_Dwg_Entity_MTEXT_auto_height_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_flow_reversed_set", _wrap_Dwg_Entity_MTEXT_flow_reversed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_flow_reversed_get", _wrap_Dwg_Entity_MTEXT_flow_reversed_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_num_column_heights_set", _wrap_Dwg_Entity_MTEXT_num_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_num_column_heights_get", _wrap_Dwg_Entity_MTEXT_num_column_heights_get, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_column_heights_set", _wrap_Dwg_Entity_MTEXT_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MTEXT_column_heights_get", _wrap_Dwg_Entity_MTEXT_column_heights_get, METH_O, NULL},
	 { "new_Dwg_Entity_MTEXT", _wrap_new_Dwg_Entity_MTEXT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MTEXT", _wrap_delete_Dwg_Entity_MTEXT, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_swigregister", Dwg_Entity_MTEXT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MTEXT_swiginit", Dwg_Entity_MTEXT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_parent_set", _wrap_Dwg_Entity_LEADER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_parent_get", _wrap_Dwg_Entity_LEADER_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_1_set", _wrap_Dwg_Entity_LEADER_unknown_bit_1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_1_get", _wrap_Dwg_Entity_LEADER_unknown_bit_1_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_path_type_set", _wrap_Dwg_Entity_LEADER_path_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_path_type_get", _wrap_Dwg_Entity_LEADER_path_type_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_annot_type_set", _wrap_Dwg_Entity_LEADER_annot_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_annot_type_get", _wrap_Dwg_Entity_LEADER_annot_type_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_num_points_set", _wrap_Dwg_Entity_LEADER_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_num_points_get", _wrap_Dwg_Entity_LEADER_num_points_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_points_set", _wrap_Dwg_Entity_LEADER_points_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_points_get", _wrap_Dwg_Entity_LEADER_points_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_origin_set", _wrap_Dwg_Entity_LEADER_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_origin_get", _wrap_Dwg_Entity_LEADER_origin_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_extrusion_set", _wrap_Dwg_Entity_LEADER_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_extrusion_get", _wrap_Dwg_Entity_LEADER_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_x_direction_set", _wrap_Dwg_Entity_LEADER_x_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_x_direction_get", _wrap_Dwg_Entity_LEADER_x_direction_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_inspt_offset_set", _wrap_Dwg_Entity_LEADER_inspt_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_inspt_offset_get", _wrap_Dwg_Entity_LEADER_inspt_offset_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_endptproj_set", _wrap_Dwg_Entity_LEADER_endptproj_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_endptproj_get", _wrap_Dwg_Entity_LEADER_endptproj_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_dimgap_set", _wrap_Dwg_Entity_LEADER_dimgap_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_dimgap_get", _wrap_Dwg_Entity_LEADER_dimgap_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_box_height_set", _wrap_Dwg_Entity_LEADER_box_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_box_height_get", _wrap_Dwg_Entity_LEADER_box_height_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_box_width_set", _wrap_Dwg_Entity_LEADER_box_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_box_width_get", _wrap_Dwg_Entity_LEADER_box_width_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_hookline_dir_set", _wrap_Dwg_Entity_LEADER_hookline_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_hookline_dir_get", _wrap_Dwg_Entity_LEADER_hookline_dir_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_hookline_on_set", _wrap_Dwg_Entity_LEADER_hookline_on_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_hookline_on_get", _wrap_Dwg_Entity_LEADER_hookline_on_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_arrowhead_on_set", _wrap_Dwg_Entity_LEADER_arrowhead_on_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_arrowhead_on_get", _wrap_Dwg_Entity_LEADER_arrowhead_on_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_arrowhead_type_set", _wrap_Dwg_Entity_LEADER_arrowhead_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_arrowhead_type_get", _wrap_Dwg_Entity_LEADER_arrowhead_type_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_dimasz_set", _wrap_Dwg_Entity_LEADER_dimasz_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_dimasz_get", _wrap_Dwg_Entity_LEADER_dimasz_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_2_set", _wrap_Dwg_Entity_LEADER_unknown_bit_2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_2_get", _wrap_Dwg_Entity_LEADER_unknown_bit_2_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_3_set", _wrap_Dwg_Entity_LEADER_unknown_bit_3_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_3_get", _wrap_Dwg_Entity_LEADER_unknown_bit_3_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_short_1_set", _wrap_Dwg_Entity_LEADER_unknown_short_1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_short_1_get", _wrap_Dwg_Entity_LEADER_unknown_short_1_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_byblock_color_set", _wrap_Dwg_Entity_LEADER_byblock_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_byblock_color_get", _wrap_Dwg_Entity_LEADER_byblock_color_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_4_set", _wrap_Dwg_Entity_LEADER_unknown_bit_4_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_4_get", _wrap_Dwg_Entity_LEADER_unknown_bit_4_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_5_set", _wrap_Dwg_Entity_LEADER_unknown_bit_5_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_unknown_bit_5_get", _wrap_Dwg_Entity_LEADER_unknown_bit_5_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_associated_annotation_set", _wrap_Dwg_Entity_LEADER_associated_annotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_associated_annotation_get", _wrap_Dwg_Entity_LEADER_associated_annotation_get, METH_O, NULL},
	 { "Dwg_Entity_LEADER_dimstyle_set", _wrap_Dwg_Entity_LEADER_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LEADER_dimstyle_get", _wrap_Dwg_Entity_LEADER_dimstyle_get, METH_O, NULL},
	 { "new_Dwg_Entity_LEADER", _wrap_new_Dwg_Entity_LEADER, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LEADER", _wrap_delete_Dwg_Entity_LEADER, METH_O, NULL},
	 { "Dwg_Entity_LEADER_swigregister", Dwg_Entity_LEADER_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LEADER_swiginit", Dwg_Entity_LEADER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_parent_set", _wrap_Dwg_Entity_TOLERANCE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_parent_get", _wrap_Dwg_Entity_TOLERANCE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_unknown_short_set", _wrap_Dwg_Entity_TOLERANCE_unknown_short_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_unknown_short_get", _wrap_Dwg_Entity_TOLERANCE_unknown_short_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_height_set", _wrap_Dwg_Entity_TOLERANCE_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_height_get", _wrap_Dwg_Entity_TOLERANCE_height_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_dimgap_set", _wrap_Dwg_Entity_TOLERANCE_dimgap_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_dimgap_get", _wrap_Dwg_Entity_TOLERANCE_dimgap_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_ins_pt_set", _wrap_Dwg_Entity_TOLERANCE_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_ins_pt_get", _wrap_Dwg_Entity_TOLERANCE_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_x_direction_set", _wrap_Dwg_Entity_TOLERANCE_x_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_x_direction_get", _wrap_Dwg_Entity_TOLERANCE_x_direction_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_extrusion_set", _wrap_Dwg_Entity_TOLERANCE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_extrusion_get", _wrap_Dwg_Entity_TOLERANCE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_text_value_set", _wrap_Dwg_Entity_TOLERANCE_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_text_value_get", _wrap_Dwg_Entity_TOLERANCE_text_value_get, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_dimstyle_set", _wrap_Dwg_Entity_TOLERANCE_dimstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TOLERANCE_dimstyle_get", _wrap_Dwg_Entity_TOLERANCE_dimstyle_get, METH_O, NULL},
	 { "new_Dwg_Entity_TOLERANCE", _wrap_new_Dwg_Entity_TOLERANCE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_TOLERANCE", _wrap_delete_Dwg_Entity_TOLERANCE, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_swigregister", Dwg_Entity_TOLERANCE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_TOLERANCE_swiginit", Dwg_Entity_TOLERANCE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_parent_set", _wrap_Dwg_MLINE_line_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_parent_get", _wrap_Dwg_MLINE_line_parent_get, METH_O, NULL},
	 { "Dwg_MLINE_line_num_segparms_set", _wrap_Dwg_MLINE_line_num_segparms_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_num_segparms_get", _wrap_Dwg_MLINE_line_num_segparms_get, METH_O, NULL},
	 { "Dwg_MLINE_line_segparms_set", _wrap_Dwg_MLINE_line_segparms_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_segparms_get", _wrap_Dwg_MLINE_line_segparms_get, METH_O, NULL},
	 { "Dwg_MLINE_line_num_areafillparms_set", _wrap_Dwg_MLINE_line_num_areafillparms_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_num_areafillparms_get", _wrap_Dwg_MLINE_line_num_areafillparms_get, METH_O, NULL},
	 { "Dwg_MLINE_line_areafillparms_set", _wrap_Dwg_MLINE_line_areafillparms_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_line_areafillparms_get", _wrap_Dwg_MLINE_line_areafillparms_get, METH_O, NULL},
	 { "new_Dwg_MLINE_line", _wrap_new_Dwg_MLINE_line, METH_NOARGS, NULL},
	 { "delete_Dwg_MLINE_line", _wrap_delete_Dwg_MLINE_line, METH_O, NULL},
	 { "Dwg_MLINE_line_swigregister", Dwg_MLINE_line_swigregister, METH_O, NULL},
	 { "Dwg_MLINE_line_swiginit", Dwg_MLINE_line_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_parent_set", _wrap_Dwg_MLINE_vertex_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_parent_get", _wrap_Dwg_MLINE_vertex_parent_get, METH_O, NULL},
	 { "Dwg_MLINE_vertex_vertex_set", _wrap_Dwg_MLINE_vertex_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_vertex_get", _wrap_Dwg_MLINE_vertex_vertex_get, METH_O, NULL},
	 { "Dwg_MLINE_vertex_vertex_direction_set", _wrap_Dwg_MLINE_vertex_vertex_direction_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_vertex_direction_get", _wrap_Dwg_MLINE_vertex_vertex_direction_get, METH_O, NULL},
	 { "Dwg_MLINE_vertex_miter_direction_set", _wrap_Dwg_MLINE_vertex_miter_direction_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_miter_direction_get", _wrap_Dwg_MLINE_vertex_miter_direction_get, METH_O, NULL},
	 { "Dwg_MLINE_vertex_num_lines_set", _wrap_Dwg_MLINE_vertex_num_lines_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_num_lines_get", _wrap_Dwg_MLINE_vertex_num_lines_get, METH_O, NULL},
	 { "Dwg_MLINE_vertex_lines_set", _wrap_Dwg_MLINE_vertex_lines_set, METH_VARARGS, NULL},
	 { "Dwg_MLINE_vertex_lines_get", _wrap_Dwg_MLINE_vertex_lines_get, METH_O, NULL},
	 { "new_Dwg_MLINE_vertex", _wrap_new_Dwg_MLINE_vertex, METH_NOARGS, NULL},
	 { "delete_Dwg_MLINE_vertex", _wrap_delete_Dwg_MLINE_vertex, METH_O, NULL},
	 { "Dwg_MLINE_vertex_swigregister", Dwg_MLINE_vertex_swigregister, METH_O, NULL},
	 { "Dwg_MLINE_vertex_swiginit", Dwg_MLINE_vertex_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_parent_set", _wrap_Dwg_Entity_MLINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_parent_get", _wrap_Dwg_Entity_MLINE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_scale_set", _wrap_Dwg_Entity_MLINE_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_scale_get", _wrap_Dwg_Entity_MLINE_scale_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_justification_set", _wrap_Dwg_Entity_MLINE_justification_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_justification_get", _wrap_Dwg_Entity_MLINE_justification_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_base_point_set", _wrap_Dwg_Entity_MLINE_base_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_base_point_get", _wrap_Dwg_Entity_MLINE_base_point_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_extrusion_set", _wrap_Dwg_Entity_MLINE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_extrusion_get", _wrap_Dwg_Entity_MLINE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_flags_set", _wrap_Dwg_Entity_MLINE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_flags_get", _wrap_Dwg_Entity_MLINE_flags_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_num_lines_set", _wrap_Dwg_Entity_MLINE_num_lines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_num_lines_get", _wrap_Dwg_Entity_MLINE_num_lines_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_num_verts_set", _wrap_Dwg_Entity_MLINE_num_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_num_verts_get", _wrap_Dwg_Entity_MLINE_num_verts_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_verts_set", _wrap_Dwg_Entity_MLINE_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_verts_get", _wrap_Dwg_Entity_MLINE_verts_get, METH_O, NULL},
	 { "Dwg_Entity_MLINE_mlinestyle_set", _wrap_Dwg_Entity_MLINE_mlinestyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MLINE_mlinestyle_get", _wrap_Dwg_Entity_MLINE_mlinestyle_get, METH_O, NULL},
	 { "new_Dwg_Entity_MLINE", _wrap_new_Dwg_Entity_MLINE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MLINE", _wrap_delete_Dwg_Entity_MLINE, METH_O, NULL},
	 { "Dwg_Entity_MLINE_swigregister", Dwg_Entity_MLINE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MLINE_swiginit", Dwg_Entity_MLINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_parent_set", _wrap_Dwg_Object_BLOCK_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_parent_get", _wrap_Dwg_Object_BLOCK_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_num_entries_set", _wrap_Dwg_Object_BLOCK_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_num_entries_get", _wrap_Dwg_Object_BLOCK_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_entries_set", _wrap_Dwg_Object_BLOCK_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_entries_get", _wrap_Dwg_Object_BLOCK_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_flags_r11_set", _wrap_Dwg_Object_BLOCK_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_flags_r11_get", _wrap_Dwg_Object_BLOCK_CONTROL_flags_r11_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_model_space_set", _wrap_Dwg_Object_BLOCK_CONTROL_model_space_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_model_space_get", _wrap_Dwg_Object_BLOCK_CONTROL_model_space_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_paper_space_set", _wrap_Dwg_Object_BLOCK_CONTROL_paper_space_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_paper_space_get", _wrap_Dwg_Object_BLOCK_CONTROL_paper_space_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCK_CONTROL", _wrap_new_Dwg_Object_BLOCK_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCK_CONTROL", _wrap_delete_Dwg_Object_BLOCK_CONTROL, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_swigregister", Dwg_Object_BLOCK_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCK_CONTROL_swiginit", Dwg_Object_BLOCK_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_parent_set", _wrap_Dwg_Object_BLOCK_HEADER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_parent_get", _wrap_Dwg_Object_BLOCK_HEADER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_flag_set", _wrap_Dwg_Object_BLOCK_HEADER_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_flag_get", _wrap_Dwg_Object_BLOCK_HEADER_flag_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_name_set", _wrap_Dwg_Object_BLOCK_HEADER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_name_get", _wrap_Dwg_Object_BLOCK_HEADER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_used_set", _wrap_Dwg_Object_BLOCK_HEADER_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_used_get", _wrap_Dwg_Object_BLOCK_HEADER_used_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_ref_set", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_ref_get", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_resolved_set", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_resolved_get", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_dep_set", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_is_xref_dep_get", _wrap_Dwg_Object_BLOCK_HEADER_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_set", _wrap_Dwg_Object_BLOCK_HEADER_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_get", _wrap_Dwg_Object_BLOCK_HEADER_xref_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER___iterator_set", _wrap_Dwg_Object_BLOCK_HEADER___iterator_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER___iterator_get", _wrap_Dwg_Object_BLOCK_HEADER___iterator_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_anonymous_set", _wrap_Dwg_Object_BLOCK_HEADER_anonymous_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_anonymous_get", _wrap_Dwg_Object_BLOCK_HEADER_anonymous_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_hasattrs_set", _wrap_Dwg_Object_BLOCK_HEADER_hasattrs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_hasattrs_get", _wrap_Dwg_Object_BLOCK_HEADER_hasattrs_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_blkisxref_set", _wrap_Dwg_Object_BLOCK_HEADER_blkisxref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_blkisxref_get", _wrap_Dwg_Object_BLOCK_HEADER_blkisxref_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xrefoverlaid_set", _wrap_Dwg_Object_BLOCK_HEADER_xrefoverlaid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xrefoverlaid_get", _wrap_Dwg_Object_BLOCK_HEADER_xrefoverlaid_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_loaded_set", _wrap_Dwg_Object_BLOCK_HEADER_xref_loaded_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_loaded_get", _wrap_Dwg_Object_BLOCK_HEADER_xref_loaded_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_num_owned_set", _wrap_Dwg_Object_BLOCK_HEADER_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_num_owned_get", _wrap_Dwg_Object_BLOCK_HEADER_num_owned_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_base_pt_set", _wrap_Dwg_Object_BLOCK_HEADER_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_base_pt_get", _wrap_Dwg_Object_BLOCK_HEADER_base_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_pname_set", _wrap_Dwg_Object_BLOCK_HEADER_xref_pname_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_xref_pname_get", _wrap_Dwg_Object_BLOCK_HEADER_xref_pname_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_num_inserts_set", _wrap_Dwg_Object_BLOCK_HEADER_num_inserts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_num_inserts_get", _wrap_Dwg_Object_BLOCK_HEADER_num_inserts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_description_set", _wrap_Dwg_Object_BLOCK_HEADER_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_description_get", _wrap_Dwg_Object_BLOCK_HEADER_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_preview_size_set", _wrap_Dwg_Object_BLOCK_HEADER_preview_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_preview_size_get", _wrap_Dwg_Object_BLOCK_HEADER_preview_size_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_preview_set", _wrap_Dwg_Object_BLOCK_HEADER_preview_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_preview_get", _wrap_Dwg_Object_BLOCK_HEADER_preview_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_insert_units_set", _wrap_Dwg_Object_BLOCK_HEADER_insert_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_insert_units_get", _wrap_Dwg_Object_BLOCK_HEADER_insert_units_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_explodable_set", _wrap_Dwg_Object_BLOCK_HEADER_explodable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_explodable_get", _wrap_Dwg_Object_BLOCK_HEADER_explodable_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_scaling_set", _wrap_Dwg_Object_BLOCK_HEADER_block_scaling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_scaling_get", _wrap_Dwg_Object_BLOCK_HEADER_block_scaling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_entity_set", _wrap_Dwg_Object_BLOCK_HEADER_block_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_entity_get", _wrap_Dwg_Object_BLOCK_HEADER_block_entity_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_first_entity_set", _wrap_Dwg_Object_BLOCK_HEADER_first_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_first_entity_get", _wrap_Dwg_Object_BLOCK_HEADER_first_entity_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_last_entity_set", _wrap_Dwg_Object_BLOCK_HEADER_last_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_last_entity_get", _wrap_Dwg_Object_BLOCK_HEADER_last_entity_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_entities_set", _wrap_Dwg_Object_BLOCK_HEADER_entities_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_entities_get", _wrap_Dwg_Object_BLOCK_HEADER_entities_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_endblk_entity_set", _wrap_Dwg_Object_BLOCK_HEADER_endblk_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_endblk_entity_get", _wrap_Dwg_Object_BLOCK_HEADER_endblk_entity_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_inserts_set", _wrap_Dwg_Object_BLOCK_HEADER_inserts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_inserts_get", _wrap_Dwg_Object_BLOCK_HEADER_inserts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_layout_set", _wrap_Dwg_Object_BLOCK_HEADER_layout_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_layout_get", _wrap_Dwg_Object_BLOCK_HEADER_layout_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_flag2_set", _wrap_Dwg_Object_BLOCK_HEADER_flag2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_flag2_get", _wrap_Dwg_Object_BLOCK_HEADER_flag2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_unknown_r11_set", _wrap_Dwg_Object_BLOCK_HEADER_unknown_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_unknown_r11_get", _wrap_Dwg_Object_BLOCK_HEADER_unknown_r11_get, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_offset_r11_set", _wrap_Dwg_Object_BLOCK_HEADER_block_offset_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCK_HEADER_block_offset_r11_get", _wrap_Dwg_Object_BLOCK_HEADER_block_offset_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCK_HEADER", _wrap_new_Dwg_Object_BLOCK_HEADER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCK_HEADER", _wrap_delete_Dwg_Object_BLOCK_HEADER, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_swigregister", Dwg_Object_BLOCK_HEADER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCK_HEADER_swiginit", Dwg_Object_BLOCK_HEADER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_CONTROL_parent_set", _wrap_Dwg_Object_LAYER_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_CONTROL_parent_get", _wrap_Dwg_Object_LAYER_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_CONTROL_num_entries_set", _wrap_Dwg_Object_LAYER_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_CONTROL_num_entries_get", _wrap_Dwg_Object_LAYER_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_CONTROL_entries_set", _wrap_Dwg_Object_LAYER_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_CONTROL_entries_get", _wrap_Dwg_Object_LAYER_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_CONTROL_flags_r11_set", _wrap_Dwg_Object_LAYER_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_CONTROL_flags_r11_get", _wrap_Dwg_Object_LAYER_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_LAYER_CONTROL", _wrap_new_Dwg_Object_LAYER_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LAYER_CONTROL", _wrap_delete_Dwg_Object_LAYER_CONTROL, METH_O, NULL},
	 { "Dwg_Object_LAYER_CONTROL_swigregister", Dwg_Object_LAYER_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_LAYER_CONTROL_swiginit", Dwg_Object_LAYER_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_parent_set", _wrap_Dwg_Object_LAYER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_parent_get", _wrap_Dwg_Object_LAYER_parent_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_flag_set", _wrap_Dwg_Object_LAYER_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_flag_get", _wrap_Dwg_Object_LAYER_flag_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_name_set", _wrap_Dwg_Object_LAYER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_name_get", _wrap_Dwg_Object_LAYER_name_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_used_set", _wrap_Dwg_Object_LAYER_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_used_get", _wrap_Dwg_Object_LAYER_used_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_is_xref_ref_set", _wrap_Dwg_Object_LAYER_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_is_xref_ref_get", _wrap_Dwg_Object_LAYER_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_is_xref_resolved_set", _wrap_Dwg_Object_LAYER_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_is_xref_resolved_get", _wrap_Dwg_Object_LAYER_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_is_xref_dep_set", _wrap_Dwg_Object_LAYER_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_is_xref_dep_get", _wrap_Dwg_Object_LAYER_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_xref_set", _wrap_Dwg_Object_LAYER_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_xref_get", _wrap_Dwg_Object_LAYER_xref_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_flag0_set", _wrap_Dwg_Object_LAYER_flag0_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_flag0_get", _wrap_Dwg_Object_LAYER_flag0_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_frozen_set", _wrap_Dwg_Object_LAYER_frozen_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_frozen_get", _wrap_Dwg_Object_LAYER_frozen_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_off_set", _wrap_Dwg_Object_LAYER_off_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_off_get", _wrap_Dwg_Object_LAYER_off_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_frozen_in_new_set", _wrap_Dwg_Object_LAYER_frozen_in_new_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_frozen_in_new_get", _wrap_Dwg_Object_LAYER_frozen_in_new_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_locked_set", _wrap_Dwg_Object_LAYER_locked_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_locked_get", _wrap_Dwg_Object_LAYER_locked_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_plotflag_set", _wrap_Dwg_Object_LAYER_plotflag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_plotflag_get", _wrap_Dwg_Object_LAYER_plotflag_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_linewt_set", _wrap_Dwg_Object_LAYER_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_linewt_get", _wrap_Dwg_Object_LAYER_linewt_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_color_set", _wrap_Dwg_Object_LAYER_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_color_get", _wrap_Dwg_Object_LAYER_color_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_plotstyle_set", _wrap_Dwg_Object_LAYER_plotstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_plotstyle_get", _wrap_Dwg_Object_LAYER_plotstyle_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_material_set", _wrap_Dwg_Object_LAYER_material_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_material_get", _wrap_Dwg_Object_LAYER_material_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_ltype_set", _wrap_Dwg_Object_LAYER_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_ltype_get", _wrap_Dwg_Object_LAYER_ltype_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_visualstyle_set", _wrap_Dwg_Object_LAYER_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_visualstyle_get", _wrap_Dwg_Object_LAYER_visualstyle_get, METH_O, NULL},
	 { "new_Dwg_Object_LAYER", _wrap_new_Dwg_Object_LAYER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LAYER", _wrap_delete_Dwg_Object_LAYER, METH_O, NULL},
	 { "Dwg_Object_LAYER_swigregister", Dwg_Object_LAYER_swigregister, METH_O, NULL},
	 { "Dwg_Object_LAYER_swiginit", Dwg_Object_LAYER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_CONTROL_parent_set", _wrap_Dwg_Object_STYLE_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_CONTROL_parent_get", _wrap_Dwg_Object_STYLE_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_CONTROL_num_entries_set", _wrap_Dwg_Object_STYLE_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_CONTROL_num_entries_get", _wrap_Dwg_Object_STYLE_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_CONTROL_entries_set", _wrap_Dwg_Object_STYLE_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_CONTROL_entries_get", _wrap_Dwg_Object_STYLE_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_CONTROL_flags_r11_set", _wrap_Dwg_Object_STYLE_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_CONTROL_flags_r11_get", _wrap_Dwg_Object_STYLE_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_STYLE_CONTROL", _wrap_new_Dwg_Object_STYLE_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_STYLE_CONTROL", _wrap_delete_Dwg_Object_STYLE_CONTROL, METH_O, NULL},
	 { "Dwg_Object_STYLE_CONTROL_swigregister", Dwg_Object_STYLE_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_STYLE_CONTROL_swiginit", Dwg_Object_STYLE_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_parent_set", _wrap_Dwg_Object_STYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_parent_get", _wrap_Dwg_Object_STYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_flag_set", _wrap_Dwg_Object_STYLE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_flag_get", _wrap_Dwg_Object_STYLE_flag_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_name_set", _wrap_Dwg_Object_STYLE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_name_get", _wrap_Dwg_Object_STYLE_name_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_used_set", _wrap_Dwg_Object_STYLE_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_used_get", _wrap_Dwg_Object_STYLE_used_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_is_xref_ref_set", _wrap_Dwg_Object_STYLE_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_is_xref_ref_get", _wrap_Dwg_Object_STYLE_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_is_xref_resolved_set", _wrap_Dwg_Object_STYLE_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_is_xref_resolved_get", _wrap_Dwg_Object_STYLE_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_is_xref_dep_set", _wrap_Dwg_Object_STYLE_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_is_xref_dep_get", _wrap_Dwg_Object_STYLE_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_xref_set", _wrap_Dwg_Object_STYLE_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_xref_get", _wrap_Dwg_Object_STYLE_xref_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_is_shape_set", _wrap_Dwg_Object_STYLE_is_shape_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_is_shape_get", _wrap_Dwg_Object_STYLE_is_shape_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_is_vertical_set", _wrap_Dwg_Object_STYLE_is_vertical_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_is_vertical_get", _wrap_Dwg_Object_STYLE_is_vertical_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_text_size_set", _wrap_Dwg_Object_STYLE_text_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_text_size_get", _wrap_Dwg_Object_STYLE_text_size_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_width_factor_set", _wrap_Dwg_Object_STYLE_width_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_width_factor_get", _wrap_Dwg_Object_STYLE_width_factor_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_oblique_angle_set", _wrap_Dwg_Object_STYLE_oblique_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_oblique_angle_get", _wrap_Dwg_Object_STYLE_oblique_angle_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_generation_set", _wrap_Dwg_Object_STYLE_generation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_generation_get", _wrap_Dwg_Object_STYLE_generation_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_last_height_set", _wrap_Dwg_Object_STYLE_last_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_last_height_get", _wrap_Dwg_Object_STYLE_last_height_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_font_file_set", _wrap_Dwg_Object_STYLE_font_file_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_font_file_get", _wrap_Dwg_Object_STYLE_font_file_get, METH_O, NULL},
	 { "Dwg_Object_STYLE_bigfont_file_set", _wrap_Dwg_Object_STYLE_bigfont_file_set, METH_VARARGS, NULL},
	 { "Dwg_Object_STYLE_bigfont_file_get", _wrap_Dwg_Object_STYLE_bigfont_file_get, METH_O, NULL},
	 { "new_Dwg_Object_STYLE", _wrap_new_Dwg_Object_STYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_STYLE", _wrap_delete_Dwg_Object_STYLE, METH_O, NULL},
	 { "Dwg_Object_STYLE_swigregister", Dwg_Object_STYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_STYLE_swiginit", Dwg_Object_STYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_parent_set", _wrap_Dwg_Object_LTYPE_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_parent_get", _wrap_Dwg_Object_LTYPE_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_num_entries_set", _wrap_Dwg_Object_LTYPE_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_num_entries_get", _wrap_Dwg_Object_LTYPE_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_entries_set", _wrap_Dwg_Object_LTYPE_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_entries_get", _wrap_Dwg_Object_LTYPE_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_flags_r11_set", _wrap_Dwg_Object_LTYPE_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_flags_r11_get", _wrap_Dwg_Object_LTYPE_CONTROL_flags_r11_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_bylayer_set", _wrap_Dwg_Object_LTYPE_CONTROL_bylayer_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_bylayer_get", _wrap_Dwg_Object_LTYPE_CONTROL_bylayer_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_byblock_set", _wrap_Dwg_Object_LTYPE_CONTROL_byblock_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_byblock_get", _wrap_Dwg_Object_LTYPE_CONTROL_byblock_get, METH_O, NULL},
	 { "new_Dwg_Object_LTYPE_CONTROL", _wrap_new_Dwg_Object_LTYPE_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LTYPE_CONTROL", _wrap_delete_Dwg_Object_LTYPE_CONTROL, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_swigregister", Dwg_Object_LTYPE_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_LTYPE_CONTROL_swiginit", Dwg_Object_LTYPE_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_parent_set", _wrap_Dwg_LTYPE_dash_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_parent_get", _wrap_Dwg_LTYPE_dash_parent_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_length_set", _wrap_Dwg_LTYPE_dash_length_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_length_get", _wrap_Dwg_LTYPE_dash_length_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_complex_shapecode_set", _wrap_Dwg_LTYPE_dash_complex_shapecode_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_complex_shapecode_get", _wrap_Dwg_LTYPE_dash_complex_shapecode_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_style_set", _wrap_Dwg_LTYPE_dash_style_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_style_get", _wrap_Dwg_LTYPE_dash_style_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_x_offset_set", _wrap_Dwg_LTYPE_dash_x_offset_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_x_offset_get", _wrap_Dwg_LTYPE_dash_x_offset_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_y_offset_set", _wrap_Dwg_LTYPE_dash_y_offset_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_y_offset_get", _wrap_Dwg_LTYPE_dash_y_offset_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_scale_set", _wrap_Dwg_LTYPE_dash_scale_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_scale_get", _wrap_Dwg_LTYPE_dash_scale_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_rotation_set", _wrap_Dwg_LTYPE_dash_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_rotation_get", _wrap_Dwg_LTYPE_dash_rotation_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_shape_flag_set", _wrap_Dwg_LTYPE_dash_shape_flag_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_shape_flag_get", _wrap_Dwg_LTYPE_dash_shape_flag_get, METH_O, NULL},
	 { "Dwg_LTYPE_dash_text_set", _wrap_Dwg_LTYPE_dash_text_set, METH_VARARGS, NULL},
	 { "Dwg_LTYPE_dash_text_get", _wrap_Dwg_LTYPE_dash_text_get, METH_O, NULL},
	 { "new_Dwg_LTYPE_dash", _wrap_new_Dwg_LTYPE_dash, METH_NOARGS, NULL},
	 { "delete_Dwg_LTYPE_dash", _wrap_delete_Dwg_LTYPE_dash, METH_O, NULL},
	 { "Dwg_LTYPE_dash_swigregister", Dwg_LTYPE_dash_swigregister, METH_O, NULL},
	 { "Dwg_LTYPE_dash_swiginit", Dwg_LTYPE_dash_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_parent_set", _wrap_Dwg_Object_LTYPE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_parent_get", _wrap_Dwg_Object_LTYPE_parent_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_flag_set", _wrap_Dwg_Object_LTYPE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_flag_get", _wrap_Dwg_Object_LTYPE_flag_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_name_set", _wrap_Dwg_Object_LTYPE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_name_get", _wrap_Dwg_Object_LTYPE_name_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_used_set", _wrap_Dwg_Object_LTYPE_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_used_get", _wrap_Dwg_Object_LTYPE_used_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_is_xref_ref_set", _wrap_Dwg_Object_LTYPE_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_is_xref_ref_get", _wrap_Dwg_Object_LTYPE_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_is_xref_resolved_set", _wrap_Dwg_Object_LTYPE_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_is_xref_resolved_get", _wrap_Dwg_Object_LTYPE_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_is_xref_dep_set", _wrap_Dwg_Object_LTYPE_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_is_xref_dep_get", _wrap_Dwg_Object_LTYPE_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_xref_set", _wrap_Dwg_Object_LTYPE_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_xref_get", _wrap_Dwg_Object_LTYPE_xref_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_description_set", _wrap_Dwg_Object_LTYPE_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_description_get", _wrap_Dwg_Object_LTYPE_description_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_pattern_len_set", _wrap_Dwg_Object_LTYPE_pattern_len_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_pattern_len_get", _wrap_Dwg_Object_LTYPE_pattern_len_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_alignment_set", _wrap_Dwg_Object_LTYPE_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_alignment_get", _wrap_Dwg_Object_LTYPE_alignment_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_numdashes_set", _wrap_Dwg_Object_LTYPE_numdashes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_numdashes_get", _wrap_Dwg_Object_LTYPE_numdashes_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_dashes_set", _wrap_Dwg_Object_LTYPE_dashes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_dashes_get", _wrap_Dwg_Object_LTYPE_dashes_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_dashes_r11_set", _wrap_Dwg_Object_LTYPE_dashes_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_dashes_r11_get", _wrap_Dwg_Object_LTYPE_dashes_r11_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_has_strings_area_set", _wrap_Dwg_Object_LTYPE_has_strings_area_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_has_strings_area_get", _wrap_Dwg_Object_LTYPE_has_strings_area_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_strings_area_set", _wrap_Dwg_Object_LTYPE_strings_area_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_strings_area_get", _wrap_Dwg_Object_LTYPE_strings_area_get, METH_O, NULL},
	 { "Dwg_Object_LTYPE_unknown_r11_set", _wrap_Dwg_Object_LTYPE_unknown_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LTYPE_unknown_r11_get", _wrap_Dwg_Object_LTYPE_unknown_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_LTYPE", _wrap_new_Dwg_Object_LTYPE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LTYPE", _wrap_delete_Dwg_Object_LTYPE, METH_O, NULL},
	 { "Dwg_Object_LTYPE_swigregister", Dwg_Object_LTYPE_swigregister, METH_O, NULL},
	 { "Dwg_Object_LTYPE_swiginit", Dwg_Object_LTYPE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_CONTROL_parent_set", _wrap_Dwg_Object_VIEW_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_CONTROL_parent_get", _wrap_Dwg_Object_VIEW_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_CONTROL_num_entries_set", _wrap_Dwg_Object_VIEW_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_CONTROL_num_entries_get", _wrap_Dwg_Object_VIEW_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_CONTROL_entries_set", _wrap_Dwg_Object_VIEW_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_CONTROL_entries_get", _wrap_Dwg_Object_VIEW_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_CONTROL_flags_r11_set", _wrap_Dwg_Object_VIEW_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_CONTROL_flags_r11_get", _wrap_Dwg_Object_VIEW_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_VIEW_CONTROL", _wrap_new_Dwg_Object_VIEW_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VIEW_CONTROL", _wrap_delete_Dwg_Object_VIEW_CONTROL, METH_O, NULL},
	 { "Dwg_Object_VIEW_CONTROL_swigregister", Dwg_Object_VIEW_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_VIEW_CONTROL_swiginit", Dwg_Object_VIEW_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_parent_set", _wrap_Dwg_Object_VIEW_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_parent_get", _wrap_Dwg_Object_VIEW_parent_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_flag_set", _wrap_Dwg_Object_VIEW_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_flag_get", _wrap_Dwg_Object_VIEW_flag_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_name_set", _wrap_Dwg_Object_VIEW_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_name_get", _wrap_Dwg_Object_VIEW_name_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_used_set", _wrap_Dwg_Object_VIEW_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_used_get", _wrap_Dwg_Object_VIEW_used_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_is_xref_ref_set", _wrap_Dwg_Object_VIEW_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_is_xref_ref_get", _wrap_Dwg_Object_VIEW_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_is_xref_resolved_set", _wrap_Dwg_Object_VIEW_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_is_xref_resolved_get", _wrap_Dwg_Object_VIEW_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_is_xref_dep_set", _wrap_Dwg_Object_VIEW_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_is_xref_dep_get", _wrap_Dwg_Object_VIEW_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_xref_set", _wrap_Dwg_Object_VIEW_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_xref_get", _wrap_Dwg_Object_VIEW_xref_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_VIEWSIZE_set", _wrap_Dwg_Object_VIEW_VIEWSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_VIEWSIZE_get", _wrap_Dwg_Object_VIEW_VIEWSIZE_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_view_width_set", _wrap_Dwg_Object_VIEW_view_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_view_width_get", _wrap_Dwg_Object_VIEW_view_width_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_aspect_ratio_set", _wrap_Dwg_Object_VIEW_aspect_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_aspect_ratio_get", _wrap_Dwg_Object_VIEW_aspect_ratio_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_VIEWCTR_set", _wrap_Dwg_Object_VIEW_VIEWCTR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_VIEWCTR_get", _wrap_Dwg_Object_VIEW_VIEWCTR_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_view_target_set", _wrap_Dwg_Object_VIEW_view_target_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_view_target_get", _wrap_Dwg_Object_VIEW_view_target_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_VIEWDIR_set", _wrap_Dwg_Object_VIEW_VIEWDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_VIEWDIR_get", _wrap_Dwg_Object_VIEW_VIEWDIR_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_twist_angle_set", _wrap_Dwg_Object_VIEW_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_twist_angle_get", _wrap_Dwg_Object_VIEW_twist_angle_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_lens_length_set", _wrap_Dwg_Object_VIEW_lens_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_lens_length_get", _wrap_Dwg_Object_VIEW_lens_length_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_front_clip_z_set", _wrap_Dwg_Object_VIEW_front_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_front_clip_z_get", _wrap_Dwg_Object_VIEW_front_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_back_clip_z_set", _wrap_Dwg_Object_VIEW_back_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_back_clip_z_get", _wrap_Dwg_Object_VIEW_back_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_VIEWMODE_set", _wrap_Dwg_Object_VIEW_VIEWMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_VIEWMODE_get", _wrap_Dwg_Object_VIEW_VIEWMODE_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_render_mode_set", _wrap_Dwg_Object_VIEW_render_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_render_mode_get", _wrap_Dwg_Object_VIEW_render_mode_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_use_default_lights_set", _wrap_Dwg_Object_VIEW_use_default_lights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_use_default_lights_get", _wrap_Dwg_Object_VIEW_use_default_lights_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_default_lightning_type_set", _wrap_Dwg_Object_VIEW_default_lightning_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_default_lightning_type_get", _wrap_Dwg_Object_VIEW_default_lightning_type_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_brightness_set", _wrap_Dwg_Object_VIEW_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_brightness_get", _wrap_Dwg_Object_VIEW_brightness_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_contrast_set", _wrap_Dwg_Object_VIEW_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_contrast_get", _wrap_Dwg_Object_VIEW_contrast_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_ambient_color_set", _wrap_Dwg_Object_VIEW_ambient_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_ambient_color_get", _wrap_Dwg_Object_VIEW_ambient_color_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_is_pspace_set", _wrap_Dwg_Object_VIEW_is_pspace_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_is_pspace_get", _wrap_Dwg_Object_VIEW_is_pspace_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_associated_ucs_set", _wrap_Dwg_Object_VIEW_associated_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_associated_ucs_get", _wrap_Dwg_Object_VIEW_associated_ucs_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_ucsorg_set", _wrap_Dwg_Object_VIEW_ucsorg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_ucsorg_get", _wrap_Dwg_Object_VIEW_ucsorg_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_ucsxdir_set", _wrap_Dwg_Object_VIEW_ucsxdir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_ucsxdir_get", _wrap_Dwg_Object_VIEW_ucsxdir_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_ucsydir_set", _wrap_Dwg_Object_VIEW_ucsydir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_ucsydir_get", _wrap_Dwg_Object_VIEW_ucsydir_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_ucs_elevation_set", _wrap_Dwg_Object_VIEW_ucs_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_ucs_elevation_get", _wrap_Dwg_Object_VIEW_ucs_elevation_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_UCSORTHOVIEW_set", _wrap_Dwg_Object_VIEW_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_UCSORTHOVIEW_get", _wrap_Dwg_Object_VIEW_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_is_camera_plottable_set", _wrap_Dwg_Object_VIEW_is_camera_plottable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_is_camera_plottable_get", _wrap_Dwg_Object_VIEW_is_camera_plottable_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_background_set", _wrap_Dwg_Object_VIEW_background_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_background_get", _wrap_Dwg_Object_VIEW_background_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_visualstyle_set", _wrap_Dwg_Object_VIEW_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_visualstyle_get", _wrap_Dwg_Object_VIEW_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_sun_set", _wrap_Dwg_Object_VIEW_sun_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_sun_get", _wrap_Dwg_Object_VIEW_sun_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_base_ucs_set", _wrap_Dwg_Object_VIEW_base_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_base_ucs_get", _wrap_Dwg_Object_VIEW_base_ucs_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_named_ucs_set", _wrap_Dwg_Object_VIEW_named_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_named_ucs_get", _wrap_Dwg_Object_VIEW_named_ucs_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_livesection_set", _wrap_Dwg_Object_VIEW_livesection_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_livesection_get", _wrap_Dwg_Object_VIEW_livesection_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_flag_3d_set", _wrap_Dwg_Object_VIEW_flag_3d_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_flag_3d_get", _wrap_Dwg_Object_VIEW_flag_3d_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_unknown_r2_set", _wrap_Dwg_Object_VIEW_unknown_r2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_unknown_r2_get", _wrap_Dwg_Object_VIEW_unknown_r2_get, METH_O, NULL},
	 { "Dwg_Object_VIEW_unknown_r11_set", _wrap_Dwg_Object_VIEW_unknown_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VIEW_unknown_r11_get", _wrap_Dwg_Object_VIEW_unknown_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_VIEW", _wrap_new_Dwg_Object_VIEW, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VIEW", _wrap_delete_Dwg_Object_VIEW, METH_O, NULL},
	 { "Dwg_Object_VIEW_swigregister", Dwg_Object_VIEW_swigregister, METH_O, NULL},
	 { "Dwg_Object_VIEW_swiginit", Dwg_Object_VIEW_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_CONTROL_parent_set", _wrap_Dwg_Object_UCS_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_CONTROL_parent_get", _wrap_Dwg_Object_UCS_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_UCS_CONTROL_num_entries_set", _wrap_Dwg_Object_UCS_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_CONTROL_num_entries_get", _wrap_Dwg_Object_UCS_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_UCS_CONTROL_entries_set", _wrap_Dwg_Object_UCS_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_CONTROL_entries_get", _wrap_Dwg_Object_UCS_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_UCS_CONTROL_flags_r11_set", _wrap_Dwg_Object_UCS_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_CONTROL_flags_r11_get", _wrap_Dwg_Object_UCS_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_UCS_CONTROL", _wrap_new_Dwg_Object_UCS_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_UCS_CONTROL", _wrap_delete_Dwg_Object_UCS_CONTROL, METH_O, NULL},
	 { "Dwg_Object_UCS_CONTROL_swigregister", Dwg_Object_UCS_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_UCS_CONTROL_swiginit", Dwg_Object_UCS_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_UCS_orthopts_parent_set", _wrap_Dwg_UCS_orthopts_parent_set, METH_VARARGS, NULL},
	 { "Dwg_UCS_orthopts_parent_get", _wrap_Dwg_UCS_orthopts_parent_get, METH_O, NULL},
	 { "Dwg_UCS_orthopts_type_set", _wrap_Dwg_UCS_orthopts_type_set, METH_VARARGS, NULL},
	 { "Dwg_UCS_orthopts_type_get", _wrap_Dwg_UCS_orthopts_type_get, METH_O, NULL},
	 { "Dwg_UCS_orthopts_pt_set", _wrap_Dwg_UCS_orthopts_pt_set, METH_VARARGS, NULL},
	 { "Dwg_UCS_orthopts_pt_get", _wrap_Dwg_UCS_orthopts_pt_get, METH_O, NULL},
	 { "new_Dwg_UCS_orthopts", _wrap_new_Dwg_UCS_orthopts, METH_NOARGS, NULL},
	 { "delete_Dwg_UCS_orthopts", _wrap_delete_Dwg_UCS_orthopts, METH_O, NULL},
	 { "Dwg_UCS_orthopts_swigregister", Dwg_UCS_orthopts_swigregister, METH_O, NULL},
	 { "Dwg_UCS_orthopts_swiginit", Dwg_UCS_orthopts_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_parent_set", _wrap_Dwg_Object_UCS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_parent_get", _wrap_Dwg_Object_UCS_parent_get, METH_O, NULL},
	 { "Dwg_Object_UCS_flag_set", _wrap_Dwg_Object_UCS_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_flag_get", _wrap_Dwg_Object_UCS_flag_get, METH_O, NULL},
	 { "Dwg_Object_UCS_name_set", _wrap_Dwg_Object_UCS_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_name_get", _wrap_Dwg_Object_UCS_name_get, METH_O, NULL},
	 { "Dwg_Object_UCS_used_set", _wrap_Dwg_Object_UCS_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_used_get", _wrap_Dwg_Object_UCS_used_get, METH_O, NULL},
	 { "Dwg_Object_UCS_is_xref_ref_set", _wrap_Dwg_Object_UCS_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_is_xref_ref_get", _wrap_Dwg_Object_UCS_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_UCS_is_xref_resolved_set", _wrap_Dwg_Object_UCS_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_is_xref_resolved_get", _wrap_Dwg_Object_UCS_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_UCS_is_xref_dep_set", _wrap_Dwg_Object_UCS_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_is_xref_dep_get", _wrap_Dwg_Object_UCS_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_UCS_xref_set", _wrap_Dwg_Object_UCS_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_xref_get", _wrap_Dwg_Object_UCS_xref_get, METH_O, NULL},
	 { "Dwg_Object_UCS_ucsorg_set", _wrap_Dwg_Object_UCS_ucsorg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_ucsorg_get", _wrap_Dwg_Object_UCS_ucsorg_get, METH_O, NULL},
	 { "Dwg_Object_UCS_ucsxdir_set", _wrap_Dwg_Object_UCS_ucsxdir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_ucsxdir_get", _wrap_Dwg_Object_UCS_ucsxdir_get, METH_O, NULL},
	 { "Dwg_Object_UCS_ucsydir_set", _wrap_Dwg_Object_UCS_ucsydir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_ucsydir_get", _wrap_Dwg_Object_UCS_ucsydir_get, METH_O, NULL},
	 { "Dwg_Object_UCS_ucs_elevation_set", _wrap_Dwg_Object_UCS_ucs_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_ucs_elevation_get", _wrap_Dwg_Object_UCS_ucs_elevation_get, METH_O, NULL},
	 { "Dwg_Object_UCS_UCSORTHOVIEW_set", _wrap_Dwg_Object_UCS_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_UCSORTHOVIEW_get", _wrap_Dwg_Object_UCS_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Object_UCS_base_ucs_set", _wrap_Dwg_Object_UCS_base_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_base_ucs_get", _wrap_Dwg_Object_UCS_base_ucs_get, METH_O, NULL},
	 { "Dwg_Object_UCS_named_ucs_set", _wrap_Dwg_Object_UCS_named_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_named_ucs_get", _wrap_Dwg_Object_UCS_named_ucs_get, METH_O, NULL},
	 { "Dwg_Object_UCS_num_orthopts_set", _wrap_Dwg_Object_UCS_num_orthopts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_num_orthopts_get", _wrap_Dwg_Object_UCS_num_orthopts_get, METH_O, NULL},
	 { "Dwg_Object_UCS_orthopts_set", _wrap_Dwg_Object_UCS_orthopts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UCS_orthopts_get", _wrap_Dwg_Object_UCS_orthopts_get, METH_O, NULL},
	 { "new_Dwg_Object_UCS", _wrap_new_Dwg_Object_UCS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_UCS", _wrap_delete_Dwg_Object_UCS, METH_O, NULL},
	 { "Dwg_Object_UCS_swigregister", Dwg_Object_UCS_swigregister, METH_O, NULL},
	 { "Dwg_Object_UCS_swiginit", Dwg_Object_UCS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_CONTROL_parent_set", _wrap_Dwg_Object_VPORT_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_CONTROL_parent_get", _wrap_Dwg_Object_VPORT_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_CONTROL_num_entries_set", _wrap_Dwg_Object_VPORT_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_CONTROL_num_entries_get", _wrap_Dwg_Object_VPORT_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_CONTROL_entries_set", _wrap_Dwg_Object_VPORT_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_CONTROL_entries_get", _wrap_Dwg_Object_VPORT_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_CONTROL_flags_r11_set", _wrap_Dwg_Object_VPORT_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_CONTROL_flags_r11_get", _wrap_Dwg_Object_VPORT_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_VPORT_CONTROL", _wrap_new_Dwg_Object_VPORT_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VPORT_CONTROL", _wrap_delete_Dwg_Object_VPORT_CONTROL, METH_O, NULL},
	 { "Dwg_Object_VPORT_CONTROL_swigregister", Dwg_Object_VPORT_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_VPORT_CONTROL_swiginit", Dwg_Object_VPORT_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_parent_set", _wrap_Dwg_Object_VPORT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_parent_get", _wrap_Dwg_Object_VPORT_parent_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_flag_set", _wrap_Dwg_Object_VPORT_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_flag_get", _wrap_Dwg_Object_VPORT_flag_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_name_set", _wrap_Dwg_Object_VPORT_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_name_get", _wrap_Dwg_Object_VPORT_name_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_used_set", _wrap_Dwg_Object_VPORT_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_used_get", _wrap_Dwg_Object_VPORT_used_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_is_xref_ref_set", _wrap_Dwg_Object_VPORT_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_is_xref_ref_get", _wrap_Dwg_Object_VPORT_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_is_xref_resolved_set", _wrap_Dwg_Object_VPORT_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_is_xref_resolved_get", _wrap_Dwg_Object_VPORT_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_is_xref_dep_set", _wrap_Dwg_Object_VPORT_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_is_xref_dep_get", _wrap_Dwg_Object_VPORT_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_xref_set", _wrap_Dwg_Object_VPORT_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_xref_get", _wrap_Dwg_Object_VPORT_xref_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_VIEWSIZE_set", _wrap_Dwg_Object_VPORT_VIEWSIZE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_VIEWSIZE_get", _wrap_Dwg_Object_VPORT_VIEWSIZE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_view_width_set", _wrap_Dwg_Object_VPORT_view_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_view_width_get", _wrap_Dwg_Object_VPORT_view_width_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_aspect_ratio_set", _wrap_Dwg_Object_VPORT_aspect_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_aspect_ratio_get", _wrap_Dwg_Object_VPORT_aspect_ratio_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_VIEWCTR_set", _wrap_Dwg_Object_VPORT_VIEWCTR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_VIEWCTR_get", _wrap_Dwg_Object_VPORT_VIEWCTR_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_view_target_set", _wrap_Dwg_Object_VPORT_view_target_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_view_target_get", _wrap_Dwg_Object_VPORT_view_target_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_VIEWDIR_set", _wrap_Dwg_Object_VPORT_VIEWDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_VIEWDIR_get", _wrap_Dwg_Object_VPORT_VIEWDIR_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_view_twist_set", _wrap_Dwg_Object_VPORT_view_twist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_view_twist_get", _wrap_Dwg_Object_VPORT_view_twist_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_lens_length_set", _wrap_Dwg_Object_VPORT_lens_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_lens_length_get", _wrap_Dwg_Object_VPORT_lens_length_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_front_clip_z_set", _wrap_Dwg_Object_VPORT_front_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_front_clip_z_get", _wrap_Dwg_Object_VPORT_front_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_back_clip_z_set", _wrap_Dwg_Object_VPORT_back_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_back_clip_z_get", _wrap_Dwg_Object_VPORT_back_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_VIEWMODE_set", _wrap_Dwg_Object_VPORT_VIEWMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_VIEWMODE_get", _wrap_Dwg_Object_VPORT_VIEWMODE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_render_mode_set", _wrap_Dwg_Object_VPORT_render_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_render_mode_get", _wrap_Dwg_Object_VPORT_render_mode_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_use_default_lights_set", _wrap_Dwg_Object_VPORT_use_default_lights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_use_default_lights_get", _wrap_Dwg_Object_VPORT_use_default_lights_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_default_lightning_type_set", _wrap_Dwg_Object_VPORT_default_lightning_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_default_lightning_type_get", _wrap_Dwg_Object_VPORT_default_lightning_type_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_brightness_set", _wrap_Dwg_Object_VPORT_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_brightness_get", _wrap_Dwg_Object_VPORT_brightness_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_contrast_set", _wrap_Dwg_Object_VPORT_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_contrast_get", _wrap_Dwg_Object_VPORT_contrast_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ambient_color_set", _wrap_Dwg_Object_VPORT_ambient_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ambient_color_get", _wrap_Dwg_Object_VPORT_ambient_color_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_lower_left_set", _wrap_Dwg_Object_VPORT_lower_left_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_lower_left_get", _wrap_Dwg_Object_VPORT_lower_left_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_upper_right_set", _wrap_Dwg_Object_VPORT_upper_right_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_upper_right_get", _wrap_Dwg_Object_VPORT_upper_right_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_UCSFOLLOW_set", _wrap_Dwg_Object_VPORT_UCSFOLLOW_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_UCSFOLLOW_get", _wrap_Dwg_Object_VPORT_UCSFOLLOW_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_circle_zoom_set", _wrap_Dwg_Object_VPORT_circle_zoom_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_circle_zoom_get", _wrap_Dwg_Object_VPORT_circle_zoom_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_FASTZOOM_set", _wrap_Dwg_Object_VPORT_FASTZOOM_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_FASTZOOM_get", _wrap_Dwg_Object_VPORT_FASTZOOM_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_UCSICON_set", _wrap_Dwg_Object_VPORT_UCSICON_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_UCSICON_get", _wrap_Dwg_Object_VPORT_UCSICON_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_GRIDMODE_set", _wrap_Dwg_Object_VPORT_GRIDMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_GRIDMODE_get", _wrap_Dwg_Object_VPORT_GRIDMODE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_GRIDUNIT_set", _wrap_Dwg_Object_VPORT_GRIDUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_GRIDUNIT_get", _wrap_Dwg_Object_VPORT_GRIDUNIT_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPMODE_set", _wrap_Dwg_Object_VPORT_SNAPMODE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPMODE_get", _wrap_Dwg_Object_VPORT_SNAPMODE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPSTYLE_set", _wrap_Dwg_Object_VPORT_SNAPSTYLE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPSTYLE_get", _wrap_Dwg_Object_VPORT_SNAPSTYLE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPISOPAIR_set", _wrap_Dwg_Object_VPORT_SNAPISOPAIR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPISOPAIR_get", _wrap_Dwg_Object_VPORT_SNAPISOPAIR_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPANG_set", _wrap_Dwg_Object_VPORT_SNAPANG_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPANG_get", _wrap_Dwg_Object_VPORT_SNAPANG_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPBASE_set", _wrap_Dwg_Object_VPORT_SNAPBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPBASE_get", _wrap_Dwg_Object_VPORT_SNAPBASE_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_SNAPUNIT_set", _wrap_Dwg_Object_VPORT_SNAPUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_SNAPUNIT_get", _wrap_Dwg_Object_VPORT_SNAPUNIT_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ucs_at_origin_set", _wrap_Dwg_Object_VPORT_ucs_at_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ucs_at_origin_get", _wrap_Dwg_Object_VPORT_ucs_at_origin_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_UCSVP_set", _wrap_Dwg_Object_VPORT_UCSVP_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_UCSVP_get", _wrap_Dwg_Object_VPORT_UCSVP_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ucsorg_set", _wrap_Dwg_Object_VPORT_ucsorg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ucsorg_get", _wrap_Dwg_Object_VPORT_ucsorg_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ucsxdir_set", _wrap_Dwg_Object_VPORT_ucsxdir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ucsxdir_get", _wrap_Dwg_Object_VPORT_ucsxdir_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ucsydir_set", _wrap_Dwg_Object_VPORT_ucsydir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ucsydir_get", _wrap_Dwg_Object_VPORT_ucsydir_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_ucs_elevation_set", _wrap_Dwg_Object_VPORT_ucs_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_ucs_elevation_get", _wrap_Dwg_Object_VPORT_ucs_elevation_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_UCSORTHOVIEW_set", _wrap_Dwg_Object_VPORT_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_UCSORTHOVIEW_get", _wrap_Dwg_Object_VPORT_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_grid_flags_set", _wrap_Dwg_Object_VPORT_grid_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_grid_flags_get", _wrap_Dwg_Object_VPORT_grid_flags_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_grid_major_set", _wrap_Dwg_Object_VPORT_grid_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_grid_major_get", _wrap_Dwg_Object_VPORT_grid_major_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_background_set", _wrap_Dwg_Object_VPORT_background_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_background_get", _wrap_Dwg_Object_VPORT_background_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_visualstyle_set", _wrap_Dwg_Object_VPORT_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_visualstyle_get", _wrap_Dwg_Object_VPORT_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_sun_set", _wrap_Dwg_Object_VPORT_sun_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_sun_get", _wrap_Dwg_Object_VPORT_sun_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_named_ucs_set", _wrap_Dwg_Object_VPORT_named_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_named_ucs_get", _wrap_Dwg_Object_VPORT_named_ucs_get, METH_O, NULL},
	 { "Dwg_Object_VPORT_base_ucs_set", _wrap_Dwg_Object_VPORT_base_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VPORT_base_ucs_get", _wrap_Dwg_Object_VPORT_base_ucs_get, METH_O, NULL},
	 { "new_Dwg_Object_VPORT", _wrap_new_Dwg_Object_VPORT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VPORT", _wrap_delete_Dwg_Object_VPORT, METH_O, NULL},
	 { "Dwg_Object_VPORT_swigregister", Dwg_Object_VPORT_swigregister, METH_O, NULL},
	 { "Dwg_Object_VPORT_swiginit", Dwg_Object_VPORT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_CONTROL_parent_set", _wrap_Dwg_Object_APPID_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_CONTROL_parent_get", _wrap_Dwg_Object_APPID_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_APPID_CONTROL_num_entries_set", _wrap_Dwg_Object_APPID_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_CONTROL_num_entries_get", _wrap_Dwg_Object_APPID_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_APPID_CONTROL_entries_set", _wrap_Dwg_Object_APPID_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_CONTROL_entries_get", _wrap_Dwg_Object_APPID_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_APPID_CONTROL_flags_r11_set", _wrap_Dwg_Object_APPID_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_CONTROL_flags_r11_get", _wrap_Dwg_Object_APPID_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_APPID_CONTROL", _wrap_new_Dwg_Object_APPID_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_APPID_CONTROL", _wrap_delete_Dwg_Object_APPID_CONTROL, METH_O, NULL},
	 { "Dwg_Object_APPID_CONTROL_swigregister", Dwg_Object_APPID_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_APPID_CONTROL_swiginit", Dwg_Object_APPID_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_parent_set", _wrap_Dwg_Object_APPID_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_parent_get", _wrap_Dwg_Object_APPID_parent_get, METH_O, NULL},
	 { "Dwg_Object_APPID_flag_set", _wrap_Dwg_Object_APPID_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_flag_get", _wrap_Dwg_Object_APPID_flag_get, METH_O, NULL},
	 { "Dwg_Object_APPID_name_set", _wrap_Dwg_Object_APPID_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_name_get", _wrap_Dwg_Object_APPID_name_get, METH_O, NULL},
	 { "Dwg_Object_APPID_used_set", _wrap_Dwg_Object_APPID_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_used_get", _wrap_Dwg_Object_APPID_used_get, METH_O, NULL},
	 { "Dwg_Object_APPID_is_xref_ref_set", _wrap_Dwg_Object_APPID_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_is_xref_ref_get", _wrap_Dwg_Object_APPID_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_APPID_is_xref_resolved_set", _wrap_Dwg_Object_APPID_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_is_xref_resolved_get", _wrap_Dwg_Object_APPID_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_APPID_is_xref_dep_set", _wrap_Dwg_Object_APPID_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_is_xref_dep_get", _wrap_Dwg_Object_APPID_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_APPID_xref_set", _wrap_Dwg_Object_APPID_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_xref_get", _wrap_Dwg_Object_APPID_xref_get, METH_O, NULL},
	 { "Dwg_Object_APPID_unknown_set", _wrap_Dwg_Object_APPID_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Object_APPID_unknown_get", _wrap_Dwg_Object_APPID_unknown_get, METH_O, NULL},
	 { "new_Dwg_Object_APPID", _wrap_new_Dwg_Object_APPID, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_APPID", _wrap_delete_Dwg_Object_APPID, METH_O, NULL},
	 { "Dwg_Object_APPID_swigregister", Dwg_Object_APPID_swigregister, METH_O, NULL},
	 { "Dwg_Object_APPID_swiginit", Dwg_Object_APPID_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_parent_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_parent_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_num_entries_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_num_entries_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_entries_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_entries_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_flags_r11_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_flags_r11_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_num_morehandles_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_morehandles_set", _wrap_Dwg_Object_DIMSTYLE_CONTROL_morehandles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_morehandles_get", _wrap_Dwg_Object_DIMSTYLE_CONTROL_morehandles_get, METH_O, NULL},
	 { "new_Dwg_Object_DIMSTYLE_CONTROL", _wrap_new_Dwg_Object_DIMSTYLE_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DIMSTYLE_CONTROL", _wrap_delete_Dwg_Object_DIMSTYLE_CONTROL, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_swigregister", Dwg_Object_DIMSTYLE_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_CONTROL_swiginit", Dwg_Object_DIMSTYLE_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_parent_set", _wrap_Dwg_Object_DIMSTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_parent_get", _wrap_Dwg_Object_DIMSTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_flag_set", _wrap_Dwg_Object_DIMSTYLE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_flag_get", _wrap_Dwg_Object_DIMSTYLE_flag_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_name_set", _wrap_Dwg_Object_DIMSTYLE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_name_get", _wrap_Dwg_Object_DIMSTYLE_name_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_used_set", _wrap_Dwg_Object_DIMSTYLE_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_used_get", _wrap_Dwg_Object_DIMSTYLE_used_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_ref_set", _wrap_Dwg_Object_DIMSTYLE_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_ref_get", _wrap_Dwg_Object_DIMSTYLE_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_resolved_set", _wrap_Dwg_Object_DIMSTYLE_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_resolved_get", _wrap_Dwg_Object_DIMSTYLE_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_dep_set", _wrap_Dwg_Object_DIMSTYLE_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_is_xref_dep_get", _wrap_Dwg_Object_DIMSTYLE_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_xref_set", _wrap_Dwg_Object_DIMSTYLE_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_xref_get", _wrap_Dwg_Object_DIMSTYLE_xref_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOL_set", _wrap_Dwg_Object_DIMSTYLE_DIMTOL_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOL_get", _wrap_Dwg_Object_DIMSTYLE_DIMTOL_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLIM_set", _wrap_Dwg_Object_DIMSTYLE_DIMLIM_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLIM_get", _wrap_Dwg_Object_DIMSTYLE_DIMLIM_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTIH_set", _wrap_Dwg_Object_DIMSTYLE_DIMTIH_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTIH_get", _wrap_Dwg_Object_DIMSTYLE_DIMTIH_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOH_set", _wrap_Dwg_Object_DIMSTYLE_DIMTOH_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOH_get", _wrap_Dwg_Object_DIMSTYLE_DIMTOH_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSE1_set", _wrap_Dwg_Object_DIMSTYLE_DIMSE1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSE1_get", _wrap_Dwg_Object_DIMSTYLE_DIMSE1_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSE2_set", _wrap_Dwg_Object_DIMSTYLE_DIMSE2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSE2_get", _wrap_Dwg_Object_DIMSTYLE_DIMSE2_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALT_set", _wrap_Dwg_Object_DIMSTYLE_DIMALT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALT_get", _wrap_Dwg_Object_DIMSTYLE_DIMALT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOFL_set", _wrap_Dwg_Object_DIMSTYLE_DIMTOFL_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOFL_get", _wrap_Dwg_Object_DIMSTYLE_DIMTOFL_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSAH_set", _wrap_Dwg_Object_DIMSTYLE_DIMSAH_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSAH_get", _wrap_Dwg_Object_DIMSTYLE_DIMSAH_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTIX_set", _wrap_Dwg_Object_DIMSTYLE_DIMTIX_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTIX_get", _wrap_Dwg_Object_DIMSTYLE_DIMTIX_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSOXD_set", _wrap_Dwg_Object_DIMSTYLE_DIMSOXD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSOXD_get", _wrap_Dwg_Object_DIMSTYLE_DIMSOXD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTD_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTD_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMZIN_set", _wrap_Dwg_Object_DIMSTYLE_DIMZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMZIN_get", _wrap_Dwg_Object_DIMSTYLE_DIMZIN_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSD1_set", _wrap_Dwg_Object_DIMSTYLE_DIMSD1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSD1_get", _wrap_Dwg_Object_DIMSTYLE_DIMSD1_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSD2_set", _wrap_Dwg_Object_DIMSTYLE_DIMSD2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSD2_get", _wrap_Dwg_Object_DIMSTYLE_DIMSD2_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOLJ_set", _wrap_Dwg_Object_DIMSTYLE_DIMTOLJ_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTOLJ_get", _wrap_Dwg_Object_DIMSTYLE_DIMTOLJ_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMJUST_set", _wrap_Dwg_Object_DIMSTYLE_DIMJUST_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMJUST_get", _wrap_Dwg_Object_DIMSTYLE_DIMJUST_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFIT_set", _wrap_Dwg_Object_DIMSTYLE_DIMFIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFIT_get", _wrap_Dwg_Object_DIMSTYLE_DIMFIT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMUPT_set", _wrap_Dwg_Object_DIMSTYLE_DIMUPT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMUPT_get", _wrap_Dwg_Object_DIMSTYLE_DIMUPT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTZIN_set", _wrap_Dwg_Object_DIMSTYLE_DIMTZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTZIN_get", _wrap_Dwg_Object_DIMSTYLE_DIMTZIN_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTZ_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTZ_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTZ_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTTZ_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTTZ_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTTZ_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTTZ_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTAD_set", _wrap_Dwg_Object_DIMSTYLE_DIMTAD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTAD_get", _wrap_Dwg_Object_DIMSTYLE_DIMTAD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMUNIT_set", _wrap_Dwg_Object_DIMSTYLE_DIMUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMUNIT_get", _wrap_Dwg_Object_DIMSTYLE_DIMUNIT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAUNIT_set", _wrap_Dwg_Object_DIMSTYLE_DIMAUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAUNIT_get", _wrap_Dwg_Object_DIMSTYLE_DIMAUNIT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDEC_set", _wrap_Dwg_Object_DIMSTYLE_DIMDEC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDEC_get", _wrap_Dwg_Object_DIMSTYLE_DIMDEC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTDEC_set", _wrap_Dwg_Object_DIMSTYLE_DIMTDEC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTDEC_get", _wrap_Dwg_Object_DIMSTYLE_DIMTDEC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTU_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTU_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTU_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTU_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTTD_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTTD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTTD_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTTD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSCALE_set", _wrap_Dwg_Object_DIMSTYLE_DIMSCALE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMSCALE_get", _wrap_Dwg_Object_DIMSTYLE_DIMSCALE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMASZ_set", _wrap_Dwg_Object_DIMSTYLE_DIMASZ_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMASZ_get", _wrap_Dwg_Object_DIMSTYLE_DIMASZ_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMEXO_set", _wrap_Dwg_Object_DIMSTYLE_DIMEXO_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMEXO_get", _wrap_Dwg_Object_DIMSTYLE_DIMEXO_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDLI_set", _wrap_Dwg_Object_DIMSTYLE_DIMDLI_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDLI_get", _wrap_Dwg_Object_DIMSTYLE_DIMDLI_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMEXE_set", _wrap_Dwg_Object_DIMSTYLE_DIMEXE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMEXE_get", _wrap_Dwg_Object_DIMSTYLE_DIMEXE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMRND_set", _wrap_Dwg_Object_DIMSTYLE_DIMRND_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMRND_get", _wrap_Dwg_Object_DIMSTYLE_DIMRND_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDLE_set", _wrap_Dwg_Object_DIMSTYLE_DIMDLE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDLE_get", _wrap_Dwg_Object_DIMSTYLE_DIMDLE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTP_set", _wrap_Dwg_Object_DIMSTYLE_DIMTP_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTP_get", _wrap_Dwg_Object_DIMSTYLE_DIMTP_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTM_set", _wrap_Dwg_Object_DIMSTYLE_DIMTM_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTM_get", _wrap_Dwg_Object_DIMSTYLE_DIMTM_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFXL_set", _wrap_Dwg_Object_DIMSTYLE_DIMFXL_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFXL_get", _wrap_Dwg_Object_DIMSTYLE_DIMFXL_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMJOGANG_set", _wrap_Dwg_Object_DIMSTYLE_DIMJOGANG_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMJOGANG_get", _wrap_Dwg_Object_DIMSTYLE_DIMJOGANG_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFILL_set", _wrap_Dwg_Object_DIMSTYLE_DIMTFILL_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFILL_get", _wrap_Dwg_Object_DIMSTYLE_DIMTFILL_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFILLCLR_set", _wrap_Dwg_Object_DIMSTYLE_DIMTFILLCLR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFILLCLR_get", _wrap_Dwg_Object_DIMSTYLE_DIMTFILLCLR_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAZIN_set", _wrap_Dwg_Object_DIMSTYLE_DIMAZIN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAZIN_get", _wrap_Dwg_Object_DIMSTYLE_DIMAZIN_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMARCSYM_set", _wrap_Dwg_Object_DIMSTYLE_DIMARCSYM_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMARCSYM_get", _wrap_Dwg_Object_DIMSTYLE_DIMARCSYM_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXT_set", _wrap_Dwg_Object_DIMSTYLE_DIMTXT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXT_get", _wrap_Dwg_Object_DIMSTYLE_DIMTXT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCEN_set", _wrap_Dwg_Object_DIMSTYLE_DIMCEN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCEN_get", _wrap_Dwg_Object_DIMSTYLE_DIMCEN_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTSZ_set", _wrap_Dwg_Object_DIMSTYLE_DIMTSZ_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTSZ_get", _wrap_Dwg_Object_DIMSTYLE_DIMTSZ_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTF_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTF_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTF_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTF_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLFAC_set", _wrap_Dwg_Object_DIMSTYLE_DIMLFAC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLFAC_get", _wrap_Dwg_Object_DIMSTYLE_DIMLFAC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTVP_set", _wrap_Dwg_Object_DIMSTYLE_DIMTVP_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTVP_get", _wrap_Dwg_Object_DIMSTYLE_DIMTVP_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFAC_set", _wrap_Dwg_Object_DIMSTYLE_DIMTFAC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTFAC_get", _wrap_Dwg_Object_DIMSTYLE_DIMTFAC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMGAP_set", _wrap_Dwg_Object_DIMSTYLE_DIMGAP_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMGAP_get", _wrap_Dwg_Object_DIMSTYLE_DIMGAP_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMPOST_set", _wrap_Dwg_Object_DIMSTYLE_DIMPOST_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMPOST_get", _wrap_Dwg_Object_DIMSTYLE_DIMPOST_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAPOST_set", _wrap_Dwg_Object_DIMSTYLE_DIMAPOST_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMAPOST_get", _wrap_Dwg_Object_DIMSTYLE_DIMAPOST_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK_T_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK_T_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK_T_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK_T_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK1_T_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK1_T_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK1_T_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK1_T_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK2_T_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK2_T_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK2_T_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK2_T_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTRND_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTRND_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTRND_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTRND_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRD_N_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRD_N_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRD_N_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRD_N_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRE_N_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRE_N_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRE_N_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRE_N_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRT_N_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRT_N_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRT_N_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRT_N_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRD_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRD_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRE_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRE_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRT_set", _wrap_Dwg_Object_DIMSTYLE_DIMCLRT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMCLRT_get", _wrap_Dwg_Object_DIMSTYLE_DIMCLRT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMADEC_set", _wrap_Dwg_Object_DIMSTYLE_DIMADEC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMADEC_get", _wrap_Dwg_Object_DIMSTYLE_DIMADEC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFRAC_set", _wrap_Dwg_Object_DIMSTYLE_DIMFRAC_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFRAC_get", _wrap_Dwg_Object_DIMSTYLE_DIMFRAC_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLUNIT_set", _wrap_Dwg_Object_DIMSTYLE_DIMLUNIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLUNIT_get", _wrap_Dwg_Object_DIMSTYLE_DIMLUNIT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDSEP_set", _wrap_Dwg_Object_DIMSTYLE_DIMDSEP_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMDSEP_get", _wrap_Dwg_Object_DIMSTYLE_DIMDSEP_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTMOVE_set", _wrap_Dwg_Object_DIMSTYLE_DIMTMOVE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTMOVE_get", _wrap_Dwg_Object_DIMSTYLE_DIMTMOVE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMATFIT_set", _wrap_Dwg_Object_DIMSTYLE_DIMATFIT_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMATFIT_get", _wrap_Dwg_Object_DIMSTYLE_DIMATFIT_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFXLON_set", _wrap_Dwg_Object_DIMSTYLE_DIMFXLON_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMFXLON_get", _wrap_Dwg_Object_DIMSTYLE_DIMFXLON_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set", _wrap_Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_get", _wrap_Dwg_Object_DIMSTYLE_DIMTXTDIRECTION_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTMZF_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTMZF_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTMZF_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTMZF_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTMZS_set", _wrap_Dwg_Object_DIMSTYLE_DIMALTMZS_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMALTMZS_get", _wrap_Dwg_Object_DIMSTYLE_DIMALTMZS_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMMZF_set", _wrap_Dwg_Object_DIMSTYLE_DIMMZF_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMMZF_get", _wrap_Dwg_Object_DIMSTYLE_DIMMZF_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMMZS_set", _wrap_Dwg_Object_DIMSTYLE_DIMMZS_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMMZS_get", _wrap_Dwg_Object_DIMSTYLE_DIMMZS_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLWD_set", _wrap_Dwg_Object_DIMSTYLE_DIMLWD_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLWD_get", _wrap_Dwg_Object_DIMSTYLE_DIMLWD_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLWE_set", _wrap_Dwg_Object_DIMSTYLE_DIMLWE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLWE_get", _wrap_Dwg_Object_DIMSTYLE_DIMLWE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_flag0_set", _wrap_Dwg_Object_DIMSTYLE_flag0_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_flag0_get", _wrap_Dwg_Object_DIMSTYLE_flag0_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXSTY_set", _wrap_Dwg_Object_DIMSTYLE_DIMTXSTY_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMTXSTY_get", _wrap_Dwg_Object_DIMSTYLE_DIMTXSTY_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLDRBLK_set", _wrap_Dwg_Object_DIMSTYLE_DIMLDRBLK_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLDRBLK_get", _wrap_Dwg_Object_DIMSTYLE_DIMLDRBLK_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK1_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK1_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK1_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK2_set", _wrap_Dwg_Object_DIMSTYLE_DIMBLK2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMBLK2_get", _wrap_Dwg_Object_DIMSTYLE_DIMBLK2_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTYPE_set", _wrap_Dwg_Object_DIMSTYLE_DIMLTYPE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTYPE_get", _wrap_Dwg_Object_DIMSTYLE_DIMLTYPE_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTEX1_set", _wrap_Dwg_Object_DIMSTYLE_DIMLTEX1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTEX1_get", _wrap_Dwg_Object_DIMSTYLE_DIMLTEX1_get, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTEX2_set", _wrap_Dwg_Object_DIMSTYLE_DIMLTEX2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMSTYLE_DIMLTEX2_get", _wrap_Dwg_Object_DIMSTYLE_DIMLTEX2_get, METH_O, NULL},
	 { "new_Dwg_Object_DIMSTYLE", _wrap_new_Dwg_Object_DIMSTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DIMSTYLE", _wrap_delete_Dwg_Object_DIMSTYLE, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_swigregister", Dwg_Object_DIMSTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_DIMSTYLE_swiginit", Dwg_Object_DIMSTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_CONTROL_parent_set", _wrap_Dwg_Object_VX_CONTROL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_CONTROL_parent_get", _wrap_Dwg_Object_VX_CONTROL_parent_get, METH_O, NULL},
	 { "Dwg_Object_VX_CONTROL_num_entries_set", _wrap_Dwg_Object_VX_CONTROL_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_CONTROL_num_entries_get", _wrap_Dwg_Object_VX_CONTROL_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_VX_CONTROL_entries_set", _wrap_Dwg_Object_VX_CONTROL_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_CONTROL_entries_get", _wrap_Dwg_Object_VX_CONTROL_entries_get, METH_O, NULL},
	 { "Dwg_Object_VX_CONTROL_flags_r11_set", _wrap_Dwg_Object_VX_CONTROL_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_CONTROL_flags_r11_get", _wrap_Dwg_Object_VX_CONTROL_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Object_VX_CONTROL", _wrap_new_Dwg_Object_VX_CONTROL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VX_CONTROL", _wrap_delete_Dwg_Object_VX_CONTROL, METH_O, NULL},
	 { "Dwg_Object_VX_CONTROL_swigregister", Dwg_Object_VX_CONTROL_swigregister, METH_O, NULL},
	 { "Dwg_Object_VX_CONTROL_swiginit", Dwg_Object_VX_CONTROL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_parent_set", _wrap_Dwg_Object_VX_TABLE_RECORD_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_parent_get", _wrap_Dwg_Object_VX_TABLE_RECORD_parent_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_flag_set", _wrap_Dwg_Object_VX_TABLE_RECORD_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_flag_get", _wrap_Dwg_Object_VX_TABLE_RECORD_flag_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_name_set", _wrap_Dwg_Object_VX_TABLE_RECORD_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_name_get", _wrap_Dwg_Object_VX_TABLE_RECORD_name_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_used_set", _wrap_Dwg_Object_VX_TABLE_RECORD_used_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_used_get", _wrap_Dwg_Object_VX_TABLE_RECORD_used_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_ref_get", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_ref_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_get", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_resolved_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_xref_dep_get", _wrap_Dwg_Object_VX_TABLE_RECORD_is_xref_dep_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_xref_set", _wrap_Dwg_Object_VX_TABLE_RECORD_xref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_xref_get", _wrap_Dwg_Object_VX_TABLE_RECORD_xref_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_on_set", _wrap_Dwg_Object_VX_TABLE_RECORD_is_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_is_on_get", _wrap_Dwg_Object_VX_TABLE_RECORD_is_on_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_viewport_set", _wrap_Dwg_Object_VX_TABLE_RECORD_viewport_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_viewport_get", _wrap_Dwg_Object_VX_TABLE_RECORD_viewport_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_prev_entry_set", _wrap_Dwg_Object_VX_TABLE_RECORD_prev_entry_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_prev_entry_get", _wrap_Dwg_Object_VX_TABLE_RECORD_prev_entry_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set", _wrap_Dwg_Object_VX_TABLE_RECORD_vport_entity_address_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_vport_entity_address_get", _wrap_Dwg_Object_VX_TABLE_RECORD_vport_entity_address_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set", _wrap_Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_get", _wrap_Dwg_Object_VX_TABLE_RECORD_r11_viewport_index_get, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set", _wrap_Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_get", _wrap_Dwg_Object_VX_TABLE_RECORD_r11_prev_entry_index_get, METH_O, NULL},
	 { "new_Dwg_Object_VX_TABLE_RECORD", _wrap_new_Dwg_Object_VX_TABLE_RECORD, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VX_TABLE_RECORD", _wrap_delete_Dwg_Object_VX_TABLE_RECORD, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_swigregister", Dwg_Object_VX_TABLE_RECORD_swigregister, METH_O, NULL},
	 { "Dwg_Object_VX_TABLE_RECORD_swiginit", Dwg_Object_VX_TABLE_RECORD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_parent_set", _wrap_Dwg_Object_GROUP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_parent_get", _wrap_Dwg_Object_GROUP_parent_get, METH_O, NULL},
	 { "Dwg_Object_GROUP_name_set", _wrap_Dwg_Object_GROUP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_name_get", _wrap_Dwg_Object_GROUP_name_get, METH_O, NULL},
	 { "Dwg_Object_GROUP_unnamed_set", _wrap_Dwg_Object_GROUP_unnamed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_unnamed_get", _wrap_Dwg_Object_GROUP_unnamed_get, METH_O, NULL},
	 { "Dwg_Object_GROUP_selectable_set", _wrap_Dwg_Object_GROUP_selectable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_selectable_get", _wrap_Dwg_Object_GROUP_selectable_get, METH_O, NULL},
	 { "Dwg_Object_GROUP_num_groups_set", _wrap_Dwg_Object_GROUP_num_groups_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_num_groups_get", _wrap_Dwg_Object_GROUP_num_groups_get, METH_O, NULL},
	 { "Dwg_Object_GROUP_groups_set", _wrap_Dwg_Object_GROUP_groups_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUP_groups_get", _wrap_Dwg_Object_GROUP_groups_get, METH_O, NULL},
	 { "new_Dwg_Object_GROUP", _wrap_new_Dwg_Object_GROUP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_GROUP", _wrap_delete_Dwg_Object_GROUP, METH_O, NULL},
	 { "Dwg_Object_GROUP_swigregister", Dwg_Object_GROUP_swigregister, METH_O, NULL},
	 { "Dwg_Object_GROUP_swiginit", Dwg_Object_GROUP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLINESTYLE_line_parent_set", _wrap_Dwg_MLINESTYLE_line_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MLINESTYLE_line_parent_get", _wrap_Dwg_MLINESTYLE_line_parent_get, METH_O, NULL},
	 { "Dwg_MLINESTYLE_line_offset_set", _wrap_Dwg_MLINESTYLE_line_offset_set, METH_VARARGS, NULL},
	 { "Dwg_MLINESTYLE_line_offset_get", _wrap_Dwg_MLINESTYLE_line_offset_get, METH_O, NULL},
	 { "Dwg_MLINESTYLE_line_color_set", _wrap_Dwg_MLINESTYLE_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_MLINESTYLE_line_color_get", _wrap_Dwg_MLINESTYLE_line_color_get, METH_O, NULL},
	 { "Dwg_MLINESTYLE_line_lt_get", _wrap_Dwg_MLINESTYLE_line_lt_get, METH_O, NULL},
	 { "new_Dwg_MLINESTYLE_line", _wrap_new_Dwg_MLINESTYLE_line, METH_NOARGS, NULL},
	 { "delete_Dwg_MLINESTYLE_line", _wrap_delete_Dwg_MLINESTYLE_line, METH_O, NULL},
	 { "Dwg_MLINESTYLE_line_swigregister", Dwg_MLINESTYLE_line_swigregister, METH_O, NULL},
	 { "Dwg_MLINESTYLE_line_swiginit", Dwg_MLINESTYLE_line_swiginit, METH_VARARGS, NULL},
	 { "_dwg_MLINESTYLE_line_lt_index_set", _wrap__dwg_MLINESTYLE_line_lt_index_set, METH_VARARGS, NULL},
	 { "_dwg_MLINESTYLE_line_lt_index_get", _wrap__dwg_MLINESTYLE_line_lt_index_get, METH_O, NULL},
	 { "_dwg_MLINESTYLE_line_lt_ltype_set", _wrap__dwg_MLINESTYLE_line_lt_ltype_set, METH_VARARGS, NULL},
	 { "_dwg_MLINESTYLE_line_lt_ltype_get", _wrap__dwg_MLINESTYLE_line_lt_ltype_get, METH_O, NULL},
	 { "new__dwg_MLINESTYLE_line_lt", _wrap_new__dwg_MLINESTYLE_line_lt, METH_NOARGS, NULL},
	 { "delete__dwg_MLINESTYLE_line_lt", _wrap_delete__dwg_MLINESTYLE_line_lt, METH_O, NULL},
	 { "_dwg_MLINESTYLE_line_lt_swigregister", _dwg_MLINESTYLE_line_lt_swigregister, METH_O, NULL},
	 { "_dwg_MLINESTYLE_line_lt_swiginit", _dwg_MLINESTYLE_line_lt_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_parent_set", _wrap_Dwg_Object_MLINESTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_parent_get", _wrap_Dwg_Object_MLINESTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_name_set", _wrap_Dwg_Object_MLINESTYLE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_name_get", _wrap_Dwg_Object_MLINESTYLE_name_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_description_set", _wrap_Dwg_Object_MLINESTYLE_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_description_get", _wrap_Dwg_Object_MLINESTYLE_description_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_flag_set", _wrap_Dwg_Object_MLINESTYLE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_flag_get", _wrap_Dwg_Object_MLINESTYLE_flag_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_fill_color_set", _wrap_Dwg_Object_MLINESTYLE_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_fill_color_get", _wrap_Dwg_Object_MLINESTYLE_fill_color_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_start_angle_set", _wrap_Dwg_Object_MLINESTYLE_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_start_angle_get", _wrap_Dwg_Object_MLINESTYLE_start_angle_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_end_angle_set", _wrap_Dwg_Object_MLINESTYLE_end_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_end_angle_get", _wrap_Dwg_Object_MLINESTYLE_end_angle_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_num_lines_set", _wrap_Dwg_Object_MLINESTYLE_num_lines_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_num_lines_get", _wrap_Dwg_Object_MLINESTYLE_num_lines_get, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_lines_set", _wrap_Dwg_Object_MLINESTYLE_lines_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLINESTYLE_lines_get", _wrap_Dwg_Object_MLINESTYLE_lines_get, METH_O, NULL},
	 { "new_Dwg_Object_MLINESTYLE", _wrap_new_Dwg_Object_MLINESTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MLINESTYLE", _wrap_delete_Dwg_Object_MLINESTYLE, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_swigregister", Dwg_Object_MLINESTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_MLINESTYLE_swiginit", Dwg_Object_MLINESTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_parent_set", _wrap_Dwg_Entity_OLE2FRAME_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_parent_get", _wrap_Dwg_Entity_OLE2FRAME_parent_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_type_set", _wrap_Dwg_Entity_OLE2FRAME_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_type_get", _wrap_Dwg_Entity_OLE2FRAME_type_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_mode_set", _wrap_Dwg_Entity_OLE2FRAME_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_mode_get", _wrap_Dwg_Entity_OLE2FRAME_mode_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_lock_aspect_set", _wrap_Dwg_Entity_OLE2FRAME_lock_aspect_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_lock_aspect_get", _wrap_Dwg_Entity_OLE2FRAME_lock_aspect_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_data_size_set", _wrap_Dwg_Entity_OLE2FRAME_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_data_size_get", _wrap_Dwg_Entity_OLE2FRAME_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_data_set", _wrap_Dwg_Entity_OLE2FRAME_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_data_get", _wrap_Dwg_Entity_OLE2FRAME_data_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_oleversion_set", _wrap_Dwg_Entity_OLE2FRAME_oleversion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_oleversion_get", _wrap_Dwg_Entity_OLE2FRAME_oleversion_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_oleclient_set", _wrap_Dwg_Entity_OLE2FRAME_oleclient_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_oleclient_get", _wrap_Dwg_Entity_OLE2FRAME_oleclient_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_pt1_set", _wrap_Dwg_Entity_OLE2FRAME_pt1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_pt1_get", _wrap_Dwg_Entity_OLE2FRAME_pt1_get, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_pt2_set", _wrap_Dwg_Entity_OLE2FRAME_pt2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_OLE2FRAME_pt2_get", _wrap_Dwg_Entity_OLE2FRAME_pt2_get, METH_O, NULL},
	 { "new_Dwg_Entity_OLE2FRAME", _wrap_new_Dwg_Entity_OLE2FRAME, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_OLE2FRAME", _wrap_delete_Dwg_Entity_OLE2FRAME, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_swigregister", Dwg_Entity_OLE2FRAME_swigregister, METH_O, NULL},
	 { "Dwg_Entity_OLE2FRAME_swiginit", Dwg_Entity_OLE2FRAME_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DUMMY_parent_set", _wrap_Dwg_Object_DUMMY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DUMMY_parent_get", _wrap_Dwg_Object_DUMMY_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_DUMMY", _wrap_new_Dwg_Object_DUMMY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DUMMY", _wrap_delete_Dwg_Object_DUMMY, METH_O, NULL},
	 { "Dwg_Object_DUMMY_swigregister", Dwg_Object_DUMMY_swigregister, METH_O, NULL},
	 { "Dwg_Object_DUMMY_swiginit", Dwg_Object_DUMMY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LONG_TRANSACTION_parent_set", _wrap_Dwg_Object_LONG_TRANSACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LONG_TRANSACTION_parent_get", _wrap_Dwg_Object_LONG_TRANSACTION_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_LONG_TRANSACTION", _wrap_new_Dwg_Object_LONG_TRANSACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LONG_TRANSACTION", _wrap_delete_Dwg_Object_LONG_TRANSACTION, METH_O, NULL},
	 { "Dwg_Object_LONG_TRANSACTION_swigregister", Dwg_Object_LONG_TRANSACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_LONG_TRANSACTION_swiginit", Dwg_Object_LONG_TRANSACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LWPOLYLINE_width_start_set", _wrap_Dwg_LWPOLYLINE_width_start_set, METH_VARARGS, NULL},
	 { "Dwg_LWPOLYLINE_width_start_get", _wrap_Dwg_LWPOLYLINE_width_start_get, METH_O, NULL},
	 { "Dwg_LWPOLYLINE_width_end_set", _wrap_Dwg_LWPOLYLINE_width_end_set, METH_VARARGS, NULL},
	 { "Dwg_LWPOLYLINE_width_end_get", _wrap_Dwg_LWPOLYLINE_width_end_get, METH_O, NULL},
	 { "new_Dwg_LWPOLYLINE_width", _wrap_new_Dwg_LWPOLYLINE_width, METH_NOARGS, NULL},
	 { "delete_Dwg_LWPOLYLINE_width", _wrap_delete_Dwg_LWPOLYLINE_width, METH_O, NULL},
	 { "Dwg_LWPOLYLINE_width_swigregister", Dwg_LWPOLYLINE_width_swigregister, METH_O, NULL},
	 { "Dwg_LWPOLYLINE_width_swiginit", Dwg_LWPOLYLINE_width_swiginit, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_parent_set", _wrap_Dwg_PROXY_LWPOLYLINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_parent_get", _wrap_Dwg_PROXY_LWPOLYLINE_parent_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_data_size_set", _wrap_Dwg_PROXY_LWPOLYLINE_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_data_size_get", _wrap_Dwg_PROXY_LWPOLYLINE_data_size_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_flags_set", _wrap_Dwg_PROXY_LWPOLYLINE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_flags_get", _wrap_Dwg_PROXY_LWPOLYLINE_flags_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_const_width_set", _wrap_Dwg_PROXY_LWPOLYLINE_const_width_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_const_width_get", _wrap_Dwg_PROXY_LWPOLYLINE_const_width_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_elevation_set", _wrap_Dwg_PROXY_LWPOLYLINE_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_elevation_get", _wrap_Dwg_PROXY_LWPOLYLINE_elevation_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_thickness_set", _wrap_Dwg_PROXY_LWPOLYLINE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_thickness_get", _wrap_Dwg_PROXY_LWPOLYLINE_thickness_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_extrusion_set", _wrap_Dwg_PROXY_LWPOLYLINE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_extrusion_get", _wrap_Dwg_PROXY_LWPOLYLINE_extrusion_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_points_set", _wrap_Dwg_PROXY_LWPOLYLINE_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_points_get", _wrap_Dwg_PROXY_LWPOLYLINE_num_points_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_points_set", _wrap_Dwg_PROXY_LWPOLYLINE_points_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_points_get", _wrap_Dwg_PROXY_LWPOLYLINE_points_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_bulges_set", _wrap_Dwg_PROXY_LWPOLYLINE_num_bulges_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_bulges_get", _wrap_Dwg_PROXY_LWPOLYLINE_num_bulges_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_bulges_set", _wrap_Dwg_PROXY_LWPOLYLINE_bulges_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_bulges_get", _wrap_Dwg_PROXY_LWPOLYLINE_bulges_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_widths_set", _wrap_Dwg_PROXY_LWPOLYLINE_num_widths_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_num_widths_get", _wrap_Dwg_PROXY_LWPOLYLINE_num_widths_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_widths_set", _wrap_Dwg_PROXY_LWPOLYLINE_widths_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_widths_get", _wrap_Dwg_PROXY_LWPOLYLINE_widths_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_1_set", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_1_get", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_1_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_2_set", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_2_get", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_2_get, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_3_set", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_3_set, METH_VARARGS, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_unknown_3_get", _wrap_Dwg_PROXY_LWPOLYLINE_unknown_3_get, METH_O, NULL},
	 { "new_Dwg_PROXY_LWPOLYLINE", _wrap_new_Dwg_PROXY_LWPOLYLINE, METH_NOARGS, NULL},
	 { "delete_Dwg_PROXY_LWPOLYLINE", _wrap_delete_Dwg_PROXY_LWPOLYLINE, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_swigregister", Dwg_PROXY_LWPOLYLINE_swigregister, METH_O, NULL},
	 { "Dwg_PROXY_LWPOLYLINE_swiginit", Dwg_PROXY_LWPOLYLINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_parent_set", _wrap_Dwg_Entity_PROXY_ENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_parent_get", _wrap_Dwg_Entity_PROXY_ENTITY_parent_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_id_set", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_id_get", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_id_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_class_id_set", _wrap_Dwg_Entity_PROXY_ENTITY_class_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_class_id_get", _wrap_Dwg_Entity_PROXY_ENTITY_class_id_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_dwg_versions_set", _wrap_Dwg_Entity_PROXY_ENTITY_dwg_versions_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_dwg_versions_get", _wrap_Dwg_Entity_PROXY_ENTITY_dwg_versions_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_maint_version_set", _wrap_Dwg_Entity_PROXY_ENTITY_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_maint_version_get", _wrap_Dwg_Entity_PROXY_ENTITY_maint_version_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_dwg_version_set", _wrap_Dwg_Entity_PROXY_ENTITY_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_dwg_version_get", _wrap_Dwg_Entity_PROXY_ENTITY_dwg_version_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_from_dxf_set", _wrap_Dwg_Entity_PROXY_ENTITY_from_dxf_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_from_dxf_get", _wrap_Dwg_Entity_PROXY_ENTITY_from_dxf_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_data_size_set", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_data_size_get", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_data_set", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_proxy_data_get", _wrap_Dwg_Entity_PROXY_ENTITY_proxy_data_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_numbits_set", _wrap_Dwg_Entity_PROXY_ENTITY_data_numbits_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_numbits_get", _wrap_Dwg_Entity_PROXY_ENTITY_data_numbits_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_size_set", _wrap_Dwg_Entity_PROXY_ENTITY_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_size_get", _wrap_Dwg_Entity_PROXY_ENTITY_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_set", _wrap_Dwg_Entity_PROXY_ENTITY_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_data_get", _wrap_Dwg_Entity_PROXY_ENTITY_data_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_num_objids_set", _wrap_Dwg_Entity_PROXY_ENTITY_num_objids_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_num_objids_get", _wrap_Dwg_Entity_PROXY_ENTITY_num_objids_get, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_objids_set", _wrap_Dwg_Entity_PROXY_ENTITY_objids_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_objids_get", _wrap_Dwg_Entity_PROXY_ENTITY_objids_get, METH_O, NULL},
	 { "new_Dwg_Entity_PROXY_ENTITY", _wrap_new_Dwg_Entity_PROXY_ENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_PROXY_ENTITY", _wrap_delete_Dwg_Entity_PROXY_ENTITY, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_swigregister", Dwg_Entity_PROXY_ENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_PROXY_ENTITY_swiginit", Dwg_Entity_PROXY_ENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_parent_set", _wrap_Dwg_Object_PROXY_OBJECT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_parent_get", _wrap_Dwg_Object_PROXY_OBJECT_parent_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_proxy_id_set", _wrap_Dwg_Object_PROXY_OBJECT_proxy_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_proxy_id_get", _wrap_Dwg_Object_PROXY_OBJECT_proxy_id_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_class_id_set", _wrap_Dwg_Object_PROXY_OBJECT_class_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_class_id_get", _wrap_Dwg_Object_PROXY_OBJECT_class_id_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_dwg_versions_set", _wrap_Dwg_Object_PROXY_OBJECT_dwg_versions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_dwg_versions_get", _wrap_Dwg_Object_PROXY_OBJECT_dwg_versions_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_maint_version_set", _wrap_Dwg_Object_PROXY_OBJECT_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_maint_version_get", _wrap_Dwg_Object_PROXY_OBJECT_maint_version_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_dwg_version_set", _wrap_Dwg_Object_PROXY_OBJECT_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_dwg_version_get", _wrap_Dwg_Object_PROXY_OBJECT_dwg_version_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_from_dxf_set", _wrap_Dwg_Object_PROXY_OBJECT_from_dxf_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_from_dxf_get", _wrap_Dwg_Object_PROXY_OBJECT_from_dxf_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_numbits_set", _wrap_Dwg_Object_PROXY_OBJECT_data_numbits_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_numbits_get", _wrap_Dwg_Object_PROXY_OBJECT_data_numbits_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_size_set", _wrap_Dwg_Object_PROXY_OBJECT_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_size_get", _wrap_Dwg_Object_PROXY_OBJECT_data_size_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_set", _wrap_Dwg_Object_PROXY_OBJECT_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_data_get", _wrap_Dwg_Object_PROXY_OBJECT_data_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_num_objids_set", _wrap_Dwg_Object_PROXY_OBJECT_num_objids_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_num_objids_get", _wrap_Dwg_Object_PROXY_OBJECT_num_objids_get, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_objids_set", _wrap_Dwg_Object_PROXY_OBJECT_objids_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PROXY_OBJECT_objids_get", _wrap_Dwg_Object_PROXY_OBJECT_objids_get, METH_O, NULL},
	 { "new_Dwg_Object_PROXY_OBJECT", _wrap_new_Dwg_Object_PROXY_OBJECT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_PROXY_OBJECT", _wrap_delete_Dwg_Object_PROXY_OBJECT, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_swigregister", Dwg_Object_PROXY_OBJECT_swigregister, METH_O, NULL},
	 { "Dwg_Object_PROXY_OBJECT_swiginit", Dwg_Object_PROXY_OBJECT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Color_parent_set", _wrap_Dwg_HATCH_Color_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Color_parent_get", _wrap_Dwg_HATCH_Color_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_Color_shift_value_set", _wrap_Dwg_HATCH_Color_shift_value_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Color_shift_value_get", _wrap_Dwg_HATCH_Color_shift_value_get, METH_O, NULL},
	 { "Dwg_HATCH_Color_color_set", _wrap_Dwg_HATCH_Color_color_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Color_color_get", _wrap_Dwg_HATCH_Color_color_get, METH_O, NULL},
	 { "new_Dwg_HATCH_Color", _wrap_new_Dwg_HATCH_Color, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_Color", _wrap_delete_Dwg_HATCH_Color, METH_O, NULL},
	 { "Dwg_HATCH_Color_swigregister", Dwg_HATCH_Color_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_Color_swiginit", Dwg_HATCH_Color_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_ControlPoint_parent_set", _wrap_Dwg_HATCH_ControlPoint_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_ControlPoint_parent_get", _wrap_Dwg_HATCH_ControlPoint_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_ControlPoint_point_set", _wrap_Dwg_HATCH_ControlPoint_point_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_ControlPoint_point_get", _wrap_Dwg_HATCH_ControlPoint_point_get, METH_O, NULL},
	 { "Dwg_HATCH_ControlPoint_weight_set", _wrap_Dwg_HATCH_ControlPoint_weight_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_ControlPoint_weight_get", _wrap_Dwg_HATCH_ControlPoint_weight_get, METH_O, NULL},
	 { "new_Dwg_HATCH_ControlPoint", _wrap_new_Dwg_HATCH_ControlPoint, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_ControlPoint", _wrap_delete_Dwg_HATCH_ControlPoint, METH_O, NULL},
	 { "Dwg_HATCH_ControlPoint_swigregister", Dwg_HATCH_ControlPoint_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_ControlPoint_swiginit", Dwg_HATCH_ControlPoint_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_parent_set", _wrap_Dwg_HATCH_PathSeg_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_parent_get", _wrap_Dwg_HATCH_PathSeg_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_curve_type_set", _wrap_Dwg_HATCH_PathSeg_curve_type_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_curve_type_get", _wrap_Dwg_HATCH_PathSeg_curve_type_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_first_endpoint_set", _wrap_Dwg_HATCH_PathSeg_first_endpoint_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_first_endpoint_get", _wrap_Dwg_HATCH_PathSeg_first_endpoint_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_second_endpoint_set", _wrap_Dwg_HATCH_PathSeg_second_endpoint_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_second_endpoint_get", _wrap_Dwg_HATCH_PathSeg_second_endpoint_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_center_set", _wrap_Dwg_HATCH_PathSeg_center_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_center_get", _wrap_Dwg_HATCH_PathSeg_center_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_radius_set", _wrap_Dwg_HATCH_PathSeg_radius_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_radius_get", _wrap_Dwg_HATCH_PathSeg_radius_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_start_angle_set", _wrap_Dwg_HATCH_PathSeg_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_start_angle_get", _wrap_Dwg_HATCH_PathSeg_start_angle_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_end_angle_set", _wrap_Dwg_HATCH_PathSeg_end_angle_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_end_angle_get", _wrap_Dwg_HATCH_PathSeg_end_angle_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_is_ccw_set", _wrap_Dwg_HATCH_PathSeg_is_ccw_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_is_ccw_get", _wrap_Dwg_HATCH_PathSeg_is_ccw_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_endpoint_set", _wrap_Dwg_HATCH_PathSeg_endpoint_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_endpoint_get", _wrap_Dwg_HATCH_PathSeg_endpoint_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_minor_major_ratio_set", _wrap_Dwg_HATCH_PathSeg_minor_major_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_minor_major_ratio_get", _wrap_Dwg_HATCH_PathSeg_minor_major_ratio_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_degree_set", _wrap_Dwg_HATCH_PathSeg_degree_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_degree_get", _wrap_Dwg_HATCH_PathSeg_degree_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_is_rational_set", _wrap_Dwg_HATCH_PathSeg_is_rational_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_is_rational_get", _wrap_Dwg_HATCH_PathSeg_is_rational_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_is_periodic_set", _wrap_Dwg_HATCH_PathSeg_is_periodic_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_is_periodic_get", _wrap_Dwg_HATCH_PathSeg_is_periodic_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_num_knots_set", _wrap_Dwg_HATCH_PathSeg_num_knots_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_num_knots_get", _wrap_Dwg_HATCH_PathSeg_num_knots_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_num_control_points_set", _wrap_Dwg_HATCH_PathSeg_num_control_points_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_num_control_points_get", _wrap_Dwg_HATCH_PathSeg_num_control_points_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_knots_set", _wrap_Dwg_HATCH_PathSeg_knots_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_knots_get", _wrap_Dwg_HATCH_PathSeg_knots_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_control_points_set", _wrap_Dwg_HATCH_PathSeg_control_points_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_control_points_get", _wrap_Dwg_HATCH_PathSeg_control_points_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_num_fitpts_set", _wrap_Dwg_HATCH_PathSeg_num_fitpts_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_num_fitpts_get", _wrap_Dwg_HATCH_PathSeg_num_fitpts_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_fitpts_set", _wrap_Dwg_HATCH_PathSeg_fitpts_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_fitpts_get", _wrap_Dwg_HATCH_PathSeg_fitpts_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_start_tangent_set", _wrap_Dwg_HATCH_PathSeg_start_tangent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_start_tangent_get", _wrap_Dwg_HATCH_PathSeg_start_tangent_get, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_end_tangent_set", _wrap_Dwg_HATCH_PathSeg_end_tangent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PathSeg_end_tangent_get", _wrap_Dwg_HATCH_PathSeg_end_tangent_get, METH_O, NULL},
	 { "new_Dwg_HATCH_PathSeg", _wrap_new_Dwg_HATCH_PathSeg, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_PathSeg", _wrap_delete_Dwg_HATCH_PathSeg, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_swigregister", Dwg_HATCH_PathSeg_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_PathSeg_swiginit", Dwg_HATCH_PathSeg_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PolylinePath_parent_set", _wrap_Dwg_HATCH_PolylinePath_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PolylinePath_parent_get", _wrap_Dwg_HATCH_PolylinePath_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_PolylinePath_point_set", _wrap_Dwg_HATCH_PolylinePath_point_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PolylinePath_point_get", _wrap_Dwg_HATCH_PolylinePath_point_get, METH_O, NULL},
	 { "Dwg_HATCH_PolylinePath_bulge_set", _wrap_Dwg_HATCH_PolylinePath_bulge_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_PolylinePath_bulge_get", _wrap_Dwg_HATCH_PolylinePath_bulge_get, METH_O, NULL},
	 { "new_Dwg_HATCH_PolylinePath", _wrap_new_Dwg_HATCH_PolylinePath, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_PolylinePath", _wrap_delete_Dwg_HATCH_PolylinePath, METH_O, NULL},
	 { "Dwg_HATCH_PolylinePath_swigregister", Dwg_HATCH_PolylinePath_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_PolylinePath_swiginit", Dwg_HATCH_PolylinePath_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_parent_set", _wrap_Dwg_HATCH_Path_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_parent_get", _wrap_Dwg_HATCH_Path_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_flag_set", _wrap_Dwg_HATCH_Path_flag_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_flag_get", _wrap_Dwg_HATCH_Path_flag_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_num_segs_or_paths_set", _wrap_Dwg_HATCH_Path_num_segs_or_paths_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_num_segs_or_paths_get", _wrap_Dwg_HATCH_Path_num_segs_or_paths_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_segs_set", _wrap_Dwg_HATCH_Path_segs_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_segs_get", _wrap_Dwg_HATCH_Path_segs_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_bulges_present_set", _wrap_Dwg_HATCH_Path_bulges_present_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_bulges_present_get", _wrap_Dwg_HATCH_Path_bulges_present_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_closed_set", _wrap_Dwg_HATCH_Path_closed_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_closed_get", _wrap_Dwg_HATCH_Path_closed_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_polyline_paths_set", _wrap_Dwg_HATCH_Path_polyline_paths_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_polyline_paths_get", _wrap_Dwg_HATCH_Path_polyline_paths_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_num_boundary_handles_set", _wrap_Dwg_HATCH_Path_num_boundary_handles_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_num_boundary_handles_get", _wrap_Dwg_HATCH_Path_num_boundary_handles_get, METH_O, NULL},
	 { "Dwg_HATCH_Path_boundary_handles_set", _wrap_Dwg_HATCH_Path_boundary_handles_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_Path_boundary_handles_get", _wrap_Dwg_HATCH_Path_boundary_handles_get, METH_O, NULL},
	 { "new_Dwg_HATCH_Path", _wrap_new_Dwg_HATCH_Path, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_Path", _wrap_delete_Dwg_HATCH_Path, METH_O, NULL},
	 { "Dwg_HATCH_Path_swigregister", Dwg_HATCH_Path_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_Path_swiginit", Dwg_HATCH_Path_swiginit, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_parent_set", _wrap_Dwg_HATCH_DefLine_parent_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_parent_get", _wrap_Dwg_HATCH_DefLine_parent_get, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_angle_set", _wrap_Dwg_HATCH_DefLine_angle_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_angle_get", _wrap_Dwg_HATCH_DefLine_angle_get, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_pt0_set", _wrap_Dwg_HATCH_DefLine_pt0_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_pt0_get", _wrap_Dwg_HATCH_DefLine_pt0_get, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_offset_set", _wrap_Dwg_HATCH_DefLine_offset_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_offset_get", _wrap_Dwg_HATCH_DefLine_offset_get, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_num_dashes_set", _wrap_Dwg_HATCH_DefLine_num_dashes_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_num_dashes_get", _wrap_Dwg_HATCH_DefLine_num_dashes_get, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_dashes_set", _wrap_Dwg_HATCH_DefLine_dashes_set, METH_VARARGS, NULL},
	 { "Dwg_HATCH_DefLine_dashes_get", _wrap_Dwg_HATCH_DefLine_dashes_get, METH_O, NULL},
	 { "new_Dwg_HATCH_DefLine", _wrap_new_Dwg_HATCH_DefLine, METH_NOARGS, NULL},
	 { "delete_Dwg_HATCH_DefLine", _wrap_delete_Dwg_HATCH_DefLine, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_swigregister", Dwg_HATCH_DefLine_swigregister, METH_O, NULL},
	 { "Dwg_HATCH_DefLine_swiginit", Dwg_HATCH_DefLine_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_parent_set", _wrap_Dwg_Entity_HATCH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_parent_get", _wrap_Dwg_Entity_HATCH_parent_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_is_gradient_fill_set", _wrap_Dwg_Entity_HATCH_is_gradient_fill_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_is_gradient_fill_get", _wrap_Dwg_Entity_HATCH_is_gradient_fill_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_reserved_set", _wrap_Dwg_Entity_HATCH_reserved_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_reserved_get", _wrap_Dwg_Entity_HATCH_reserved_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_gradient_angle_set", _wrap_Dwg_Entity_HATCH_gradient_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_gradient_angle_get", _wrap_Dwg_Entity_HATCH_gradient_angle_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_gradient_shift_set", _wrap_Dwg_Entity_HATCH_gradient_shift_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_gradient_shift_get", _wrap_Dwg_Entity_HATCH_gradient_shift_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_single_color_gradient_set", _wrap_Dwg_Entity_HATCH_single_color_gradient_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_single_color_gradient_get", _wrap_Dwg_Entity_HATCH_single_color_gradient_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_gradient_tint_set", _wrap_Dwg_Entity_HATCH_gradient_tint_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_gradient_tint_get", _wrap_Dwg_Entity_HATCH_gradient_tint_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_num_colors_set", _wrap_Dwg_Entity_HATCH_num_colors_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_num_colors_get", _wrap_Dwg_Entity_HATCH_num_colors_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_colors_set", _wrap_Dwg_Entity_HATCH_colors_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_colors_get", _wrap_Dwg_Entity_HATCH_colors_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_gradient_name_set", _wrap_Dwg_Entity_HATCH_gradient_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_gradient_name_get", _wrap_Dwg_Entity_HATCH_gradient_name_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_elevation_set", _wrap_Dwg_Entity_HATCH_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_elevation_get", _wrap_Dwg_Entity_HATCH_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_extrusion_set", _wrap_Dwg_Entity_HATCH_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_extrusion_get", _wrap_Dwg_Entity_HATCH_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_name_set", _wrap_Dwg_Entity_HATCH_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_name_get", _wrap_Dwg_Entity_HATCH_name_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_is_solid_fill_set", _wrap_Dwg_Entity_HATCH_is_solid_fill_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_is_solid_fill_get", _wrap_Dwg_Entity_HATCH_is_solid_fill_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_is_associative_set", _wrap_Dwg_Entity_HATCH_is_associative_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_is_associative_get", _wrap_Dwg_Entity_HATCH_is_associative_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_num_paths_set", _wrap_Dwg_Entity_HATCH_num_paths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_num_paths_get", _wrap_Dwg_Entity_HATCH_num_paths_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_paths_set", _wrap_Dwg_Entity_HATCH_paths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_paths_get", _wrap_Dwg_Entity_HATCH_paths_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_style_set", _wrap_Dwg_Entity_HATCH_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_style_get", _wrap_Dwg_Entity_HATCH_style_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_pattern_type_set", _wrap_Dwg_Entity_HATCH_pattern_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_pattern_type_get", _wrap_Dwg_Entity_HATCH_pattern_type_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_angle_set", _wrap_Dwg_Entity_HATCH_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_angle_get", _wrap_Dwg_Entity_HATCH_angle_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_scale_spacing_set", _wrap_Dwg_Entity_HATCH_scale_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_scale_spacing_get", _wrap_Dwg_Entity_HATCH_scale_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_double_flag_set", _wrap_Dwg_Entity_HATCH_double_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_double_flag_get", _wrap_Dwg_Entity_HATCH_double_flag_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_num_deflines_set", _wrap_Dwg_Entity_HATCH_num_deflines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_num_deflines_get", _wrap_Dwg_Entity_HATCH_num_deflines_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_deflines_set", _wrap_Dwg_Entity_HATCH_deflines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_deflines_get", _wrap_Dwg_Entity_HATCH_deflines_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_has_derived_set", _wrap_Dwg_Entity_HATCH_has_derived_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_has_derived_get", _wrap_Dwg_Entity_HATCH_has_derived_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_pixel_size_set", _wrap_Dwg_Entity_HATCH_pixel_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_pixel_size_get", _wrap_Dwg_Entity_HATCH_pixel_size_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_num_seeds_set", _wrap_Dwg_Entity_HATCH_num_seeds_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_num_seeds_get", _wrap_Dwg_Entity_HATCH_num_seeds_get, METH_O, NULL},
	 { "Dwg_Entity_HATCH_seeds_set", _wrap_Dwg_Entity_HATCH_seeds_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HATCH_seeds_get", _wrap_Dwg_Entity_HATCH_seeds_get, METH_O, NULL},
	 { "new_Dwg_Entity_HATCH", _wrap_new_Dwg_Entity_HATCH, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_HATCH", _wrap_delete_Dwg_Entity_HATCH, METH_O, NULL},
	 { "Dwg_Entity_HATCH_swigregister", Dwg_Entity_HATCH_swigregister, METH_O, NULL},
	 { "Dwg_Entity_HATCH_swiginit", Dwg_Entity_HATCH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_parent_set", _wrap_Dwg_Entity_MPOLYGON_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_parent_get", _wrap_Dwg_Entity_MPOLYGON_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_is_gradient_fill_set", _wrap_Dwg_Entity_MPOLYGON_is_gradient_fill_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_is_gradient_fill_get", _wrap_Dwg_Entity_MPOLYGON_is_gradient_fill_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_reserved_set", _wrap_Dwg_Entity_MPOLYGON_reserved_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_reserved_get", _wrap_Dwg_Entity_MPOLYGON_reserved_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_angle_set", _wrap_Dwg_Entity_MPOLYGON_gradient_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_angle_get", _wrap_Dwg_Entity_MPOLYGON_gradient_angle_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_shift_set", _wrap_Dwg_Entity_MPOLYGON_gradient_shift_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_shift_get", _wrap_Dwg_Entity_MPOLYGON_gradient_shift_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_single_color_gradient_set", _wrap_Dwg_Entity_MPOLYGON_single_color_gradient_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_single_color_gradient_get", _wrap_Dwg_Entity_MPOLYGON_single_color_gradient_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_tint_set", _wrap_Dwg_Entity_MPOLYGON_gradient_tint_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_tint_get", _wrap_Dwg_Entity_MPOLYGON_gradient_tint_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_num_colors_set", _wrap_Dwg_Entity_MPOLYGON_num_colors_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_num_colors_get", _wrap_Dwg_Entity_MPOLYGON_num_colors_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_colors_set", _wrap_Dwg_Entity_MPOLYGON_colors_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_colors_get", _wrap_Dwg_Entity_MPOLYGON_colors_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_name_set", _wrap_Dwg_Entity_MPOLYGON_gradient_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_gradient_name_get", _wrap_Dwg_Entity_MPOLYGON_gradient_name_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_elevation_set", _wrap_Dwg_Entity_MPOLYGON_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_elevation_get", _wrap_Dwg_Entity_MPOLYGON_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_extrusion_set", _wrap_Dwg_Entity_MPOLYGON_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_extrusion_get", _wrap_Dwg_Entity_MPOLYGON_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_name_set", _wrap_Dwg_Entity_MPOLYGON_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_name_get", _wrap_Dwg_Entity_MPOLYGON_name_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_is_solid_fill_set", _wrap_Dwg_Entity_MPOLYGON_is_solid_fill_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_is_solid_fill_get", _wrap_Dwg_Entity_MPOLYGON_is_solid_fill_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_is_associative_set", _wrap_Dwg_Entity_MPOLYGON_is_associative_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_is_associative_get", _wrap_Dwg_Entity_MPOLYGON_is_associative_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_num_paths_set", _wrap_Dwg_Entity_MPOLYGON_num_paths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_num_paths_get", _wrap_Dwg_Entity_MPOLYGON_num_paths_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_paths_set", _wrap_Dwg_Entity_MPOLYGON_paths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_paths_get", _wrap_Dwg_Entity_MPOLYGON_paths_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_style_set", _wrap_Dwg_Entity_MPOLYGON_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_style_get", _wrap_Dwg_Entity_MPOLYGON_style_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_pattern_type_set", _wrap_Dwg_Entity_MPOLYGON_pattern_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_pattern_type_get", _wrap_Dwg_Entity_MPOLYGON_pattern_type_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_angle_set", _wrap_Dwg_Entity_MPOLYGON_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_angle_get", _wrap_Dwg_Entity_MPOLYGON_angle_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_scale_spacing_set", _wrap_Dwg_Entity_MPOLYGON_scale_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_scale_spacing_get", _wrap_Dwg_Entity_MPOLYGON_scale_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_double_flag_set", _wrap_Dwg_Entity_MPOLYGON_double_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_double_flag_get", _wrap_Dwg_Entity_MPOLYGON_double_flag_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_num_deflines_set", _wrap_Dwg_Entity_MPOLYGON_num_deflines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_num_deflines_get", _wrap_Dwg_Entity_MPOLYGON_num_deflines_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_deflines_set", _wrap_Dwg_Entity_MPOLYGON_deflines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_deflines_get", _wrap_Dwg_Entity_MPOLYGON_deflines_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_hatch_color_set", _wrap_Dwg_Entity_MPOLYGON_hatch_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_hatch_color_get", _wrap_Dwg_Entity_MPOLYGON_hatch_color_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_x_dir_set", _wrap_Dwg_Entity_MPOLYGON_x_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_x_dir_get", _wrap_Dwg_Entity_MPOLYGON_x_dir_get, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_num_boundary_handles_set", _wrap_Dwg_Entity_MPOLYGON_num_boundary_handles_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MPOLYGON_num_boundary_handles_get", _wrap_Dwg_Entity_MPOLYGON_num_boundary_handles_get, METH_O, NULL},
	 { "new_Dwg_Entity_MPOLYGON", _wrap_new_Dwg_Entity_MPOLYGON, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MPOLYGON", _wrap_delete_Dwg_Entity_MPOLYGON, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_swigregister", Dwg_Entity_MPOLYGON_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MPOLYGON_swiginit", Dwg_Entity_MPOLYGON_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_parent_set", _wrap_Dwg_Object_XRECORD_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_parent_get", _wrap_Dwg_Object_XRECORD_parent_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_cloning_set", _wrap_Dwg_Object_XRECORD_cloning_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_cloning_get", _wrap_Dwg_Object_XRECORD_cloning_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_xdata_size_set", _wrap_Dwg_Object_XRECORD_xdata_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_xdata_size_get", _wrap_Dwg_Object_XRECORD_xdata_size_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_num_xdata_set", _wrap_Dwg_Object_XRECORD_num_xdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_num_xdata_get", _wrap_Dwg_Object_XRECORD_num_xdata_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_xdata_set", _wrap_Dwg_Object_XRECORD_xdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_xdata_get", _wrap_Dwg_Object_XRECORD_xdata_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_num_objid_handles_set", _wrap_Dwg_Object_XRECORD_num_objid_handles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_num_objid_handles_get", _wrap_Dwg_Object_XRECORD_num_objid_handles_get, METH_O, NULL},
	 { "Dwg_Object_XRECORD_objid_handles_set", _wrap_Dwg_Object_XRECORD_objid_handles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_XRECORD_objid_handles_get", _wrap_Dwg_Object_XRECORD_objid_handles_get, METH_O, NULL},
	 { "new_Dwg_Object_XRECORD", _wrap_new_Dwg_Object_XRECORD, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_XRECORD", _wrap_delete_Dwg_Object_XRECORD, METH_O, NULL},
	 { "Dwg_Object_XRECORD_swigregister", Dwg_Object_XRECORD_swigregister, METH_O, NULL},
	 { "Dwg_Object_XRECORD_swiginit", Dwg_Object_XRECORD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_PLACEHOLDER_parent_set", _wrap_Dwg_Object_PLACEHOLDER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLACEHOLDER_parent_get", _wrap_Dwg_Object_PLACEHOLDER_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_PLACEHOLDER", _wrap_new_Dwg_Object_PLACEHOLDER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_PLACEHOLDER", _wrap_delete_Dwg_Object_PLACEHOLDER, METH_O, NULL},
	 { "Dwg_Object_PLACEHOLDER_swigregister", Dwg_Object_PLACEHOLDER_swigregister, METH_O, NULL},
	 { "Dwg_Object_PLACEHOLDER_swiginit", Dwg_Object_PLACEHOLDER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Break_parent_set", _wrap_Dwg_LEADER_Break_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Break_parent_get", _wrap_Dwg_LEADER_Break_parent_get, METH_O, NULL},
	 { "Dwg_LEADER_Break_start_set", _wrap_Dwg_LEADER_Break_start_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Break_start_get", _wrap_Dwg_LEADER_Break_start_get, METH_O, NULL},
	 { "Dwg_LEADER_Break_end_set", _wrap_Dwg_LEADER_Break_end_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Break_end_get", _wrap_Dwg_LEADER_Break_end_get, METH_O, NULL},
	 { "new_Dwg_LEADER_Break", _wrap_new_Dwg_LEADER_Break, METH_NOARGS, NULL},
	 { "delete_Dwg_LEADER_Break", _wrap_delete_Dwg_LEADER_Break, METH_O, NULL},
	 { "Dwg_LEADER_Break_swigregister", Dwg_LEADER_Break_swigregister, METH_O, NULL},
	 { "Dwg_LEADER_Break_swiginit", Dwg_LEADER_Break_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_parent_set", _wrap_Dwg_LEADER_Line_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_parent_get", _wrap_Dwg_LEADER_Line_parent_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_num_points_set", _wrap_Dwg_LEADER_Line_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_num_points_get", _wrap_Dwg_LEADER_Line_num_points_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_points_set", _wrap_Dwg_LEADER_Line_points_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_points_get", _wrap_Dwg_LEADER_Line_points_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_num_breaks_set", _wrap_Dwg_LEADER_Line_num_breaks_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_num_breaks_get", _wrap_Dwg_LEADER_Line_num_breaks_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_breaks_set", _wrap_Dwg_LEADER_Line_breaks_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_breaks_get", _wrap_Dwg_LEADER_Line_breaks_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_line_index_set", _wrap_Dwg_LEADER_Line_line_index_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_line_index_get", _wrap_Dwg_LEADER_Line_line_index_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_type_set", _wrap_Dwg_LEADER_Line_type_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_type_get", _wrap_Dwg_LEADER_Line_type_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_color_set", _wrap_Dwg_LEADER_Line_color_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_color_get", _wrap_Dwg_LEADER_Line_color_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_ltype_set", _wrap_Dwg_LEADER_Line_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_ltype_get", _wrap_Dwg_LEADER_Line_ltype_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_linewt_set", _wrap_Dwg_LEADER_Line_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_linewt_get", _wrap_Dwg_LEADER_Line_linewt_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_arrow_size_set", _wrap_Dwg_LEADER_Line_arrow_size_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_arrow_size_get", _wrap_Dwg_LEADER_Line_arrow_size_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_arrow_handle_set", _wrap_Dwg_LEADER_Line_arrow_handle_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_arrow_handle_get", _wrap_Dwg_LEADER_Line_arrow_handle_get, METH_O, NULL},
	 { "Dwg_LEADER_Line_flags_set", _wrap_Dwg_LEADER_Line_flags_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Line_flags_get", _wrap_Dwg_LEADER_Line_flags_get, METH_O, NULL},
	 { "new_Dwg_LEADER_Line", _wrap_new_Dwg_LEADER_Line, METH_NOARGS, NULL},
	 { "delete_Dwg_LEADER_Line", _wrap_delete_Dwg_LEADER_Line, METH_O, NULL},
	 { "Dwg_LEADER_Line_swigregister", Dwg_LEADER_Line_swigregister, METH_O, NULL},
	 { "Dwg_LEADER_Line_swiginit", Dwg_LEADER_Line_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LEADER_ArrowHead_parent_set", _wrap_Dwg_LEADER_ArrowHead_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_ArrowHead_parent_get", _wrap_Dwg_LEADER_ArrowHead_parent_get, METH_O, NULL},
	 { "Dwg_LEADER_ArrowHead_is_default_set", _wrap_Dwg_LEADER_ArrowHead_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_ArrowHead_is_default_get", _wrap_Dwg_LEADER_ArrowHead_is_default_get, METH_O, NULL},
	 { "Dwg_LEADER_ArrowHead_arrowhead_set", _wrap_Dwg_LEADER_ArrowHead_arrowhead_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_ArrowHead_arrowhead_get", _wrap_Dwg_LEADER_ArrowHead_arrowhead_get, METH_O, NULL},
	 { "new_Dwg_LEADER_ArrowHead", _wrap_new_Dwg_LEADER_ArrowHead, METH_NOARGS, NULL},
	 { "delete_Dwg_LEADER_ArrowHead", _wrap_delete_Dwg_LEADER_ArrowHead, METH_O, NULL},
	 { "Dwg_LEADER_ArrowHead_swigregister", Dwg_LEADER_ArrowHead_swigregister, METH_O, NULL},
	 { "Dwg_LEADER_ArrowHead_swiginit", Dwg_LEADER_ArrowHead_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_parent_set", _wrap_Dwg_LEADER_BlockLabel_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_parent_get", _wrap_Dwg_LEADER_BlockLabel_parent_get, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_attdef_set", _wrap_Dwg_LEADER_BlockLabel_attdef_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_attdef_get", _wrap_Dwg_LEADER_BlockLabel_attdef_get, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_label_text_set", _wrap_Dwg_LEADER_BlockLabel_label_text_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_label_text_get", _wrap_Dwg_LEADER_BlockLabel_label_text_get, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_ui_index_set", _wrap_Dwg_LEADER_BlockLabel_ui_index_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_ui_index_get", _wrap_Dwg_LEADER_BlockLabel_ui_index_get, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_width_set", _wrap_Dwg_LEADER_BlockLabel_width_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_BlockLabel_width_get", _wrap_Dwg_LEADER_BlockLabel_width_get, METH_O, NULL},
	 { "new_Dwg_LEADER_BlockLabel", _wrap_new_Dwg_LEADER_BlockLabel, METH_NOARGS, NULL},
	 { "delete_Dwg_LEADER_BlockLabel", _wrap_delete_Dwg_LEADER_BlockLabel, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_swigregister", Dwg_LEADER_BlockLabel_swigregister, METH_O, NULL},
	 { "Dwg_LEADER_BlockLabel_swiginit", Dwg_LEADER_BlockLabel_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_parent_set", _wrap_Dwg_LEADER_Node_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_parent_get", _wrap_Dwg_LEADER_Node_parent_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_has_lastleaderlinepoint_set", _wrap_Dwg_LEADER_Node_has_lastleaderlinepoint_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_has_lastleaderlinepoint_get", _wrap_Dwg_LEADER_Node_has_lastleaderlinepoint_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_has_dogleg_set", _wrap_Dwg_LEADER_Node_has_dogleg_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_has_dogleg_get", _wrap_Dwg_LEADER_Node_has_dogleg_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_lastleaderlinepoint_set", _wrap_Dwg_LEADER_Node_lastleaderlinepoint_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_lastleaderlinepoint_get", _wrap_Dwg_LEADER_Node_lastleaderlinepoint_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_dogleg_vector_set", _wrap_Dwg_LEADER_Node_dogleg_vector_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_dogleg_vector_get", _wrap_Dwg_LEADER_Node_dogleg_vector_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_branch_index_set", _wrap_Dwg_LEADER_Node_branch_index_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_branch_index_get", _wrap_Dwg_LEADER_Node_branch_index_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_dogleg_length_set", _wrap_Dwg_LEADER_Node_dogleg_length_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_dogleg_length_get", _wrap_Dwg_LEADER_Node_dogleg_length_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_num_lines_set", _wrap_Dwg_LEADER_Node_num_lines_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_num_lines_get", _wrap_Dwg_LEADER_Node_num_lines_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_lines_set", _wrap_Dwg_LEADER_Node_lines_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_lines_get", _wrap_Dwg_LEADER_Node_lines_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_num_breaks_set", _wrap_Dwg_LEADER_Node_num_breaks_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_num_breaks_get", _wrap_Dwg_LEADER_Node_num_breaks_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_breaks_set", _wrap_Dwg_LEADER_Node_breaks_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_breaks_get", _wrap_Dwg_LEADER_Node_breaks_get, METH_O, NULL},
	 { "Dwg_LEADER_Node_attach_dir_set", _wrap_Dwg_LEADER_Node_attach_dir_set, METH_VARARGS, NULL},
	 { "Dwg_LEADER_Node_attach_dir_get", _wrap_Dwg_LEADER_Node_attach_dir_get, METH_O, NULL},
	 { "new_Dwg_LEADER_Node", _wrap_new_Dwg_LEADER_Node, METH_NOARGS, NULL},
	 { "delete_Dwg_LEADER_Node", _wrap_delete_Dwg_LEADER_Node, METH_O, NULL},
	 { "Dwg_LEADER_Node_swigregister", Dwg_LEADER_Node_swigregister, METH_O, NULL},
	 { "Dwg_LEADER_Node_swiginit", Dwg_LEADER_Node_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_type_set", _wrap_Dwg_MLEADER_Content_MText_type_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_type_get", _wrap_Dwg_MLEADER_Content_MText_type_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_normal_set", _wrap_Dwg_MLEADER_Content_MText_normal_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_normal_get", _wrap_Dwg_MLEADER_Content_MText_normal_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_location_set", _wrap_Dwg_MLEADER_Content_MText_location_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_location_get", _wrap_Dwg_MLEADER_Content_MText_location_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_rotation_set", _wrap_Dwg_MLEADER_Content_MText_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_rotation_get", _wrap_Dwg_MLEADER_Content_MText_rotation_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_style_set", _wrap_Dwg_MLEADER_Content_MText_style_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_style_get", _wrap_Dwg_MLEADER_Content_MText_style_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_direction_set", _wrap_Dwg_MLEADER_Content_MText_direction_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_direction_get", _wrap_Dwg_MLEADER_Content_MText_direction_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_color_set", _wrap_Dwg_MLEADER_Content_MText_color_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_color_get", _wrap_Dwg_MLEADER_Content_MText_color_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_width_set", _wrap_Dwg_MLEADER_Content_MText_width_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_width_get", _wrap_Dwg_MLEADER_Content_MText_width_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_height_set", _wrap_Dwg_MLEADER_Content_MText_height_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_height_get", _wrap_Dwg_MLEADER_Content_MText_height_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_line_spacing_factor_set", _wrap_Dwg_MLEADER_Content_MText_line_spacing_factor_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_line_spacing_factor_get", _wrap_Dwg_MLEADER_Content_MText_line_spacing_factor_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_default_text_set", _wrap_Dwg_MLEADER_Content_MText_default_text_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_default_text_get", _wrap_Dwg_MLEADER_Content_MText_default_text_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_line_spacing_style_set", _wrap_Dwg_MLEADER_Content_MText_line_spacing_style_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_line_spacing_style_get", _wrap_Dwg_MLEADER_Content_MText_line_spacing_style_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_alignment_set", _wrap_Dwg_MLEADER_Content_MText_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_alignment_get", _wrap_Dwg_MLEADER_Content_MText_alignment_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_flow_set", _wrap_Dwg_MLEADER_Content_MText_flow_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_flow_get", _wrap_Dwg_MLEADER_Content_MText_flow_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_color_set", _wrap_Dwg_MLEADER_Content_MText_bg_color_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_color_get", _wrap_Dwg_MLEADER_Content_MText_bg_color_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_scale_set", _wrap_Dwg_MLEADER_Content_MText_bg_scale_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_scale_get", _wrap_Dwg_MLEADER_Content_MText_bg_scale_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_transparency_set", _wrap_Dwg_MLEADER_Content_MText_bg_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_bg_transparency_get", _wrap_Dwg_MLEADER_Content_MText_bg_transparency_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_is_bg_fill_set", _wrap_Dwg_MLEADER_Content_MText_is_bg_fill_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_is_bg_fill_get", _wrap_Dwg_MLEADER_Content_MText_is_bg_fill_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_is_bg_mask_fill_set", _wrap_Dwg_MLEADER_Content_MText_is_bg_mask_fill_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_is_bg_mask_fill_get", _wrap_Dwg_MLEADER_Content_MText_is_bg_mask_fill_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_col_type_set", _wrap_Dwg_MLEADER_Content_MText_col_type_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_col_type_get", _wrap_Dwg_MLEADER_Content_MText_col_type_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_is_height_auto_set", _wrap_Dwg_MLEADER_Content_MText_is_height_auto_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_is_height_auto_get", _wrap_Dwg_MLEADER_Content_MText_is_height_auto_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_col_width_set", _wrap_Dwg_MLEADER_Content_MText_col_width_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_col_width_get", _wrap_Dwg_MLEADER_Content_MText_col_width_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_col_gutter_set", _wrap_Dwg_MLEADER_Content_MText_col_gutter_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_col_gutter_get", _wrap_Dwg_MLEADER_Content_MText_col_gutter_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_is_col_flow_reversed_set", _wrap_Dwg_MLEADER_Content_MText_is_col_flow_reversed_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_is_col_flow_reversed_get", _wrap_Dwg_MLEADER_Content_MText_is_col_flow_reversed_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_num_col_sizes_set", _wrap_Dwg_MLEADER_Content_MText_num_col_sizes_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_num_col_sizes_get", _wrap_Dwg_MLEADER_Content_MText_num_col_sizes_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_col_sizes_set", _wrap_Dwg_MLEADER_Content_MText_col_sizes_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_col_sizes_get", _wrap_Dwg_MLEADER_Content_MText_col_sizes_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_word_break_set", _wrap_Dwg_MLEADER_Content_MText_word_break_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_word_break_get", _wrap_Dwg_MLEADER_Content_MText_word_break_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_unknown_set", _wrap_Dwg_MLEADER_Content_MText_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_MText_unknown_get", _wrap_Dwg_MLEADER_Content_MText_unknown_get, METH_O, NULL},
	 { "new_Dwg_MLEADER_Content_MText", _wrap_new_Dwg_MLEADER_Content_MText, METH_NOARGS, NULL},
	 { "delete_Dwg_MLEADER_Content_MText", _wrap_delete_Dwg_MLEADER_Content_MText, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_swigregister", Dwg_MLEADER_Content_MText_swigregister, METH_O, NULL},
	 { "Dwg_MLEADER_Content_MText_swiginit", Dwg_MLEADER_Content_MText_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_type_set", _wrap_Dwg_MLEADER_Content_Block_type_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_type_get", _wrap_Dwg_MLEADER_Content_Block_type_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_normal_set", _wrap_Dwg_MLEADER_Content_Block_normal_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_normal_get", _wrap_Dwg_MLEADER_Content_Block_normal_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_location_set", _wrap_Dwg_MLEADER_Content_Block_location_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_location_get", _wrap_Dwg_MLEADER_Content_Block_location_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_rotation_set", _wrap_Dwg_MLEADER_Content_Block_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_rotation_get", _wrap_Dwg_MLEADER_Content_Block_rotation_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_block_table_set", _wrap_Dwg_MLEADER_Content_Block_block_table_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_block_table_get", _wrap_Dwg_MLEADER_Content_Block_block_table_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_scale_set", _wrap_Dwg_MLEADER_Content_Block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_scale_get", _wrap_Dwg_MLEADER_Content_Block_scale_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_color_set", _wrap_Dwg_MLEADER_Content_Block_color_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_color_get", _wrap_Dwg_MLEADER_Content_Block_color_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_transform_set", _wrap_Dwg_MLEADER_Content_Block_transform_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_Block_transform_get", _wrap_Dwg_MLEADER_Content_Block_transform_get, METH_O, NULL},
	 { "new_Dwg_MLEADER_Content_Block", _wrap_new_Dwg_MLEADER_Content_Block, METH_NOARGS, NULL},
	 { "delete_Dwg_MLEADER_Content_Block", _wrap_delete_Dwg_MLEADER_Content_Block, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_swigregister", Dwg_MLEADER_Content_Block_swigregister, METH_O, NULL},
	 { "Dwg_MLEADER_Content_Block_swiginit", Dwg_MLEADER_Content_Block_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_txt_set", _wrap_Dwg_MLEADER_Content_txt_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_txt_get", _wrap_Dwg_MLEADER_Content_txt_get, METH_O, NULL},
	 { "Dwg_MLEADER_Content_blk_set", _wrap_Dwg_MLEADER_Content_blk_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_Content_blk_get", _wrap_Dwg_MLEADER_Content_blk_get, METH_O, NULL},
	 { "new_Dwg_MLEADER_Content", _wrap_new_Dwg_MLEADER_Content, METH_NOARGS, NULL},
	 { "delete_Dwg_MLEADER_Content", _wrap_delete_Dwg_MLEADER_Content, METH_O, NULL},
	 { "Dwg_MLEADER_Content_swigregister", Dwg_MLEADER_Content_swigregister, METH_O, NULL},
	 { "Dwg_MLEADER_Content_swiginit", Dwg_MLEADER_Content_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_num_leaders_set", _wrap_Dwg_MLEADER_AnnotContext_num_leaders_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_num_leaders_get", _wrap_Dwg_MLEADER_AnnotContext_num_leaders_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_leaders_set", _wrap_Dwg_MLEADER_AnnotContext_leaders_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_leaders_get", _wrap_Dwg_MLEADER_AnnotContext_leaders_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_attach_dir_set", _wrap_Dwg_MLEADER_AnnotContext_attach_dir_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_attach_dir_get", _wrap_Dwg_MLEADER_AnnotContext_attach_dir_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_scale_factor_set", _wrap_Dwg_MLEADER_AnnotContext_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_scale_factor_get", _wrap_Dwg_MLEADER_AnnotContext_scale_factor_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_content_base_set", _wrap_Dwg_MLEADER_AnnotContext_content_base_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_content_base_get", _wrap_Dwg_MLEADER_AnnotContext_content_base_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_height_set", _wrap_Dwg_MLEADER_AnnotContext_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_height_get", _wrap_Dwg_MLEADER_AnnotContext_text_height_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_arrow_size_set", _wrap_Dwg_MLEADER_AnnotContext_arrow_size_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_arrow_size_get", _wrap_Dwg_MLEADER_AnnotContext_arrow_size_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_landing_gap_set", _wrap_Dwg_MLEADER_AnnotContext_landing_gap_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_landing_gap_get", _wrap_Dwg_MLEADER_AnnotContext_landing_gap_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_left_set", _wrap_Dwg_MLEADER_AnnotContext_text_left_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_left_get", _wrap_Dwg_MLEADER_AnnotContext_text_left_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_right_set", _wrap_Dwg_MLEADER_AnnotContext_text_right_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_right_get", _wrap_Dwg_MLEADER_AnnotContext_text_right_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_angletype_set", _wrap_Dwg_MLEADER_AnnotContext_text_angletype_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_angletype_get", _wrap_Dwg_MLEADER_AnnotContext_text_angletype_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_alignment_set", _wrap_Dwg_MLEADER_AnnotContext_text_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_alignment_get", _wrap_Dwg_MLEADER_AnnotContext_text_alignment_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_has_content_txt_set", _wrap_Dwg_MLEADER_AnnotContext_has_content_txt_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_has_content_txt_get", _wrap_Dwg_MLEADER_AnnotContext_has_content_txt_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_has_content_blk_set", _wrap_Dwg_MLEADER_AnnotContext_has_content_blk_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_has_content_blk_get", _wrap_Dwg_MLEADER_AnnotContext_has_content_blk_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_content_set", _wrap_Dwg_MLEADER_AnnotContext_content_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_content_get", _wrap_Dwg_MLEADER_AnnotContext_content_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_set", _wrap_Dwg_MLEADER_AnnotContext_base_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_get", _wrap_Dwg_MLEADER_AnnotContext_base_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_dir_set", _wrap_Dwg_MLEADER_AnnotContext_base_dir_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_dir_get", _wrap_Dwg_MLEADER_AnnotContext_base_dir_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_vert_set", _wrap_Dwg_MLEADER_AnnotContext_base_vert_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_base_vert_get", _wrap_Dwg_MLEADER_AnnotContext_base_vert_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_is_normal_reversed_set", _wrap_Dwg_MLEADER_AnnotContext_is_normal_reversed_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_is_normal_reversed_get", _wrap_Dwg_MLEADER_AnnotContext_is_normal_reversed_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_top_set", _wrap_Dwg_MLEADER_AnnotContext_text_top_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_top_get", _wrap_Dwg_MLEADER_AnnotContext_text_top_get, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_bottom_set", _wrap_Dwg_MLEADER_AnnotContext_text_bottom_set, METH_VARARGS, NULL},
	 { "Dwg_MLEADER_AnnotContext_text_bottom_get", _wrap_Dwg_MLEADER_AnnotContext_text_bottom_get, METH_O, NULL},
	 { "new_Dwg_MLEADER_AnnotContext", _wrap_new_Dwg_MLEADER_AnnotContext, METH_NOARGS, NULL},
	 { "delete_Dwg_MLEADER_AnnotContext", _wrap_delete_Dwg_MLEADER_AnnotContext, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_swigregister", Dwg_MLEADER_AnnotContext_swigregister, METH_O, NULL},
	 { "Dwg_MLEADER_AnnotContext_swiginit", Dwg_MLEADER_AnnotContext_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_parent_set", _wrap_Dwg_Entity_MULTILEADER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_parent_get", _wrap_Dwg_Entity_MULTILEADER_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_class_version_set", _wrap_Dwg_Entity_MULTILEADER_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_class_version_get", _wrap_Dwg_Entity_MULTILEADER_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_ctx_set", _wrap_Dwg_Entity_MULTILEADER_ctx_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_ctx_get", _wrap_Dwg_Entity_MULTILEADER_ctx_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_mleaderstyle_set", _wrap_Dwg_Entity_MULTILEADER_mleaderstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_mleaderstyle_get", _wrap_Dwg_Entity_MULTILEADER_mleaderstyle_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_flags_set", _wrap_Dwg_Entity_MULTILEADER_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_flags_get", _wrap_Dwg_Entity_MULTILEADER_flags_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_type_set", _wrap_Dwg_Entity_MULTILEADER_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_type_get", _wrap_Dwg_Entity_MULTILEADER_type_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_line_color_set", _wrap_Dwg_Entity_MULTILEADER_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_line_color_get", _wrap_Dwg_Entity_MULTILEADER_line_color_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_line_ltype_set", _wrap_Dwg_Entity_MULTILEADER_line_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_line_ltype_get", _wrap_Dwg_Entity_MULTILEADER_line_ltype_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_line_linewt_set", _wrap_Dwg_Entity_MULTILEADER_line_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_line_linewt_get", _wrap_Dwg_Entity_MULTILEADER_line_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_has_landing_set", _wrap_Dwg_Entity_MULTILEADER_has_landing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_has_landing_get", _wrap_Dwg_Entity_MULTILEADER_has_landing_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_has_dogleg_set", _wrap_Dwg_Entity_MULTILEADER_has_dogleg_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_has_dogleg_get", _wrap_Dwg_Entity_MULTILEADER_has_dogleg_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_landing_dist_set", _wrap_Dwg_Entity_MULTILEADER_landing_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_landing_dist_get", _wrap_Dwg_Entity_MULTILEADER_landing_dist_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_arrow_handle_set", _wrap_Dwg_Entity_MULTILEADER_arrow_handle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_arrow_handle_get", _wrap_Dwg_Entity_MULTILEADER_arrow_handle_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_arrow_size_set", _wrap_Dwg_Entity_MULTILEADER_arrow_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_arrow_size_get", _wrap_Dwg_Entity_MULTILEADER_arrow_size_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_style_content_set", _wrap_Dwg_Entity_MULTILEADER_style_content_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_style_content_get", _wrap_Dwg_Entity_MULTILEADER_style_content_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_style_set", _wrap_Dwg_Entity_MULTILEADER_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_style_get", _wrap_Dwg_Entity_MULTILEADER_text_style_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_left_set", _wrap_Dwg_Entity_MULTILEADER_text_left_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_left_get", _wrap_Dwg_Entity_MULTILEADER_text_left_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_right_set", _wrap_Dwg_Entity_MULTILEADER_text_right_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_right_get", _wrap_Dwg_Entity_MULTILEADER_text_right_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_angletype_set", _wrap_Dwg_Entity_MULTILEADER_text_angletype_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_angletype_get", _wrap_Dwg_Entity_MULTILEADER_text_angletype_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_alignment_set", _wrap_Dwg_Entity_MULTILEADER_text_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_alignment_get", _wrap_Dwg_Entity_MULTILEADER_text_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_text_color_set", _wrap_Dwg_Entity_MULTILEADER_text_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_text_color_get", _wrap_Dwg_Entity_MULTILEADER_text_color_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_has_text_frame_set", _wrap_Dwg_Entity_MULTILEADER_has_text_frame_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_has_text_frame_get", _wrap_Dwg_Entity_MULTILEADER_has_text_frame_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_block_style_set", _wrap_Dwg_Entity_MULTILEADER_block_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_block_style_get", _wrap_Dwg_Entity_MULTILEADER_block_style_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_block_color_set", _wrap_Dwg_Entity_MULTILEADER_block_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_block_color_get", _wrap_Dwg_Entity_MULTILEADER_block_color_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_block_scale_set", _wrap_Dwg_Entity_MULTILEADER_block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_block_scale_get", _wrap_Dwg_Entity_MULTILEADER_block_scale_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_block_rotation_set", _wrap_Dwg_Entity_MULTILEADER_block_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_block_rotation_get", _wrap_Dwg_Entity_MULTILEADER_block_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_style_attachment_set", _wrap_Dwg_Entity_MULTILEADER_style_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_style_attachment_get", _wrap_Dwg_Entity_MULTILEADER_style_attachment_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_is_annotative_set", _wrap_Dwg_Entity_MULTILEADER_is_annotative_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_is_annotative_get", _wrap_Dwg_Entity_MULTILEADER_is_annotative_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_num_arrowheads_set", _wrap_Dwg_Entity_MULTILEADER_num_arrowheads_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_num_arrowheads_get", _wrap_Dwg_Entity_MULTILEADER_num_arrowheads_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_arrowheads_set", _wrap_Dwg_Entity_MULTILEADER_arrowheads_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_arrowheads_get", _wrap_Dwg_Entity_MULTILEADER_arrowheads_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_num_blocklabels_set", _wrap_Dwg_Entity_MULTILEADER_num_blocklabels_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_num_blocklabels_get", _wrap_Dwg_Entity_MULTILEADER_num_blocklabels_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_blocklabels_set", _wrap_Dwg_Entity_MULTILEADER_blocklabels_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_blocklabels_get", _wrap_Dwg_Entity_MULTILEADER_blocklabels_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_is_neg_textdir_set", _wrap_Dwg_Entity_MULTILEADER_is_neg_textdir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_is_neg_textdir_get", _wrap_Dwg_Entity_MULTILEADER_is_neg_textdir_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_ipe_alignment_set", _wrap_Dwg_Entity_MULTILEADER_ipe_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_ipe_alignment_get", _wrap_Dwg_Entity_MULTILEADER_ipe_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_justification_set", _wrap_Dwg_Entity_MULTILEADER_justification_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_justification_get", _wrap_Dwg_Entity_MULTILEADER_justification_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_scale_factor_set", _wrap_Dwg_Entity_MULTILEADER_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_scale_factor_get", _wrap_Dwg_Entity_MULTILEADER_scale_factor_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_dir_set", _wrap_Dwg_Entity_MULTILEADER_attach_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_dir_get", _wrap_Dwg_Entity_MULTILEADER_attach_dir_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_top_set", _wrap_Dwg_Entity_MULTILEADER_attach_top_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_top_get", _wrap_Dwg_Entity_MULTILEADER_attach_top_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_bottom_set", _wrap_Dwg_Entity_MULTILEADER_attach_bottom_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_attach_bottom_get", _wrap_Dwg_Entity_MULTILEADER_attach_bottom_get, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_is_text_extended_set", _wrap_Dwg_Entity_MULTILEADER_is_text_extended_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MULTILEADER_is_text_extended_get", _wrap_Dwg_Entity_MULTILEADER_is_text_extended_get, METH_O, NULL},
	 { "new_Dwg_Entity_MULTILEADER", _wrap_new_Dwg_Entity_MULTILEADER, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MULTILEADER", _wrap_delete_Dwg_Entity_MULTILEADER, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_swigregister", Dwg_Entity_MULTILEADER_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MULTILEADER_swiginit", Dwg_Entity_MULTILEADER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_parent_set", _wrap_Dwg_Object_MLEADERSTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_parent_get", _wrap_Dwg_Object_MLEADERSTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_class_version_set", _wrap_Dwg_Object_MLEADERSTYLE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_class_version_get", _wrap_Dwg_Object_MLEADERSTYLE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_content_type_set", _wrap_Dwg_Object_MLEADERSTYLE_content_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_content_type_get", _wrap_Dwg_Object_MLEADERSTYLE_content_type_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_mleader_order_set", _wrap_Dwg_Object_MLEADERSTYLE_mleader_order_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_mleader_order_get", _wrap_Dwg_Object_MLEADERSTYLE_mleader_order_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_leader_order_set", _wrap_Dwg_Object_MLEADERSTYLE_leader_order_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_leader_order_get", _wrap_Dwg_Object_MLEADERSTYLE_leader_order_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_max_points_set", _wrap_Dwg_Object_MLEADERSTYLE_max_points_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_max_points_get", _wrap_Dwg_Object_MLEADERSTYLE_max_points_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_first_seg_angle_set", _wrap_Dwg_Object_MLEADERSTYLE_first_seg_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_first_seg_angle_get", _wrap_Dwg_Object_MLEADERSTYLE_first_seg_angle_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_second_seg_angle_set", _wrap_Dwg_Object_MLEADERSTYLE_second_seg_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_second_seg_angle_get", _wrap_Dwg_Object_MLEADERSTYLE_second_seg_angle_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_type_set", _wrap_Dwg_Object_MLEADERSTYLE_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_type_get", _wrap_Dwg_Object_MLEADERSTYLE_type_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_line_color_set", _wrap_Dwg_Object_MLEADERSTYLE_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_line_color_get", _wrap_Dwg_Object_MLEADERSTYLE_line_color_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_line_type_set", _wrap_Dwg_Object_MLEADERSTYLE_line_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_line_type_get", _wrap_Dwg_Object_MLEADERSTYLE_line_type_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_linewt_set", _wrap_Dwg_Object_MLEADERSTYLE_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_linewt_get", _wrap_Dwg_Object_MLEADERSTYLE_linewt_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_landing_set", _wrap_Dwg_Object_MLEADERSTYLE_has_landing_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_landing_get", _wrap_Dwg_Object_MLEADERSTYLE_has_landing_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_dogleg_set", _wrap_Dwg_Object_MLEADERSTYLE_has_dogleg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_dogleg_get", _wrap_Dwg_Object_MLEADERSTYLE_has_dogleg_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_landing_gap_set", _wrap_Dwg_Object_MLEADERSTYLE_landing_gap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_landing_gap_get", _wrap_Dwg_Object_MLEADERSTYLE_landing_gap_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_landing_dist_set", _wrap_Dwg_Object_MLEADERSTYLE_landing_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_landing_dist_get", _wrap_Dwg_Object_MLEADERSTYLE_landing_dist_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_description_set", _wrap_Dwg_Object_MLEADERSTYLE_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_description_get", _wrap_Dwg_Object_MLEADERSTYLE_description_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_arrow_head_set", _wrap_Dwg_Object_MLEADERSTYLE_arrow_head_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_arrow_head_get", _wrap_Dwg_Object_MLEADERSTYLE_arrow_head_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_arrow_head_size_set", _wrap_Dwg_Object_MLEADERSTYLE_arrow_head_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_arrow_head_size_get", _wrap_Dwg_Object_MLEADERSTYLE_arrow_head_size_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_default_set", _wrap_Dwg_Object_MLEADERSTYLE_text_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_default_get", _wrap_Dwg_Object_MLEADERSTYLE_text_default_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_style_set", _wrap_Dwg_Object_MLEADERSTYLE_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_style_get", _wrap_Dwg_Object_MLEADERSTYLE_text_style_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_left_set", _wrap_Dwg_Object_MLEADERSTYLE_attach_left_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_left_get", _wrap_Dwg_Object_MLEADERSTYLE_attach_left_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_right_set", _wrap_Dwg_Object_MLEADERSTYLE_attach_right_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_right_get", _wrap_Dwg_Object_MLEADERSTYLE_attach_right_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_angle_type_set", _wrap_Dwg_Object_MLEADERSTYLE_text_angle_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_angle_type_get", _wrap_Dwg_Object_MLEADERSTYLE_text_angle_type_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_align_type_set", _wrap_Dwg_Object_MLEADERSTYLE_text_align_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_align_type_get", _wrap_Dwg_Object_MLEADERSTYLE_text_align_type_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_color_set", _wrap_Dwg_Object_MLEADERSTYLE_text_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_color_get", _wrap_Dwg_Object_MLEADERSTYLE_text_color_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_height_set", _wrap_Dwg_Object_MLEADERSTYLE_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_height_get", _wrap_Dwg_Object_MLEADERSTYLE_text_height_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_text_frame_set", _wrap_Dwg_Object_MLEADERSTYLE_has_text_frame_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_has_text_frame_get", _wrap_Dwg_Object_MLEADERSTYLE_has_text_frame_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_always_left_set", _wrap_Dwg_Object_MLEADERSTYLE_text_always_left_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_always_left_get", _wrap_Dwg_Object_MLEADERSTYLE_text_always_left_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_align_space_set", _wrap_Dwg_Object_MLEADERSTYLE_align_space_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_align_space_get", _wrap_Dwg_Object_MLEADERSTYLE_align_space_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_set", _wrap_Dwg_Object_MLEADERSTYLE_block_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_get", _wrap_Dwg_Object_MLEADERSTYLE_block_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_color_set", _wrap_Dwg_Object_MLEADERSTYLE_block_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_color_get", _wrap_Dwg_Object_MLEADERSTYLE_block_color_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_scale_set", _wrap_Dwg_Object_MLEADERSTYLE_block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_scale_get", _wrap_Dwg_Object_MLEADERSTYLE_block_scale_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_use_block_scale_set", _wrap_Dwg_Object_MLEADERSTYLE_use_block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_use_block_scale_get", _wrap_Dwg_Object_MLEADERSTYLE_use_block_scale_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_rotation_set", _wrap_Dwg_Object_MLEADERSTYLE_block_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_rotation_get", _wrap_Dwg_Object_MLEADERSTYLE_block_rotation_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_use_block_rotation_set", _wrap_Dwg_Object_MLEADERSTYLE_use_block_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_use_block_rotation_get", _wrap_Dwg_Object_MLEADERSTYLE_use_block_rotation_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_connection_set", _wrap_Dwg_Object_MLEADERSTYLE_block_connection_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_block_connection_get", _wrap_Dwg_Object_MLEADERSTYLE_block_connection_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_scale_set", _wrap_Dwg_Object_MLEADERSTYLE_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_scale_get", _wrap_Dwg_Object_MLEADERSTYLE_scale_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_is_changed_set", _wrap_Dwg_Object_MLEADERSTYLE_is_changed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_is_changed_get", _wrap_Dwg_Object_MLEADERSTYLE_is_changed_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_is_annotative_set", _wrap_Dwg_Object_MLEADERSTYLE_is_annotative_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_is_annotative_get", _wrap_Dwg_Object_MLEADERSTYLE_is_annotative_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_break_size_set", _wrap_Dwg_Object_MLEADERSTYLE_break_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_break_size_get", _wrap_Dwg_Object_MLEADERSTYLE_break_size_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_dir_set", _wrap_Dwg_Object_MLEADERSTYLE_attach_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_dir_get", _wrap_Dwg_Object_MLEADERSTYLE_attach_dir_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_top_set", _wrap_Dwg_Object_MLEADERSTYLE_attach_top_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_top_get", _wrap_Dwg_Object_MLEADERSTYLE_attach_top_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_bottom_set", _wrap_Dwg_Object_MLEADERSTYLE_attach_bottom_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_attach_bottom_get", _wrap_Dwg_Object_MLEADERSTYLE_attach_bottom_get, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_extended_set", _wrap_Dwg_Object_MLEADERSTYLE_text_extended_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADERSTYLE_text_extended_get", _wrap_Dwg_Object_MLEADERSTYLE_text_extended_get, METH_O, NULL},
	 { "new_Dwg_Object_MLEADERSTYLE", _wrap_new_Dwg_Object_MLEADERSTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MLEADERSTYLE", _wrap_delete_Dwg_Object_MLEADERSTYLE, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_swigregister", Dwg_Object_MLEADERSTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_MLEADERSTYLE_swiginit", Dwg_Object_MLEADERSTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VBA_PROJECT_parent_set", _wrap_Dwg_Object_VBA_PROJECT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VBA_PROJECT_parent_get", _wrap_Dwg_Object_VBA_PROJECT_parent_get, METH_O, NULL},
	 { "Dwg_Object_VBA_PROJECT_data_size_set", _wrap_Dwg_Object_VBA_PROJECT_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VBA_PROJECT_data_size_get", _wrap_Dwg_Object_VBA_PROJECT_data_size_get, METH_O, NULL},
	 { "Dwg_Object_VBA_PROJECT_data_set", _wrap_Dwg_Object_VBA_PROJECT_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VBA_PROJECT_data_get", _wrap_Dwg_Object_VBA_PROJECT_data_get, METH_O, NULL},
	 { "new_Dwg_Object_VBA_PROJECT", _wrap_new_Dwg_Object_VBA_PROJECT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VBA_PROJECT", _wrap_delete_Dwg_Object_VBA_PROJECT, METH_O, NULL},
	 { "Dwg_Object_VBA_PROJECT_swigregister", Dwg_Object_VBA_PROJECT_swigregister, METH_O, NULL},
	 { "Dwg_Object_VBA_PROJECT_swiginit", Dwg_Object_VBA_PROJECT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_parent_set", _wrap_Dwg_Object_PLOTSETTINGS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_parent_get", _wrap_Dwg_Object_PLOTSETTINGS_parent_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_printer_cfg_file_set", _wrap_Dwg_Object_PLOTSETTINGS_printer_cfg_file_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_printer_cfg_file_get", _wrap_Dwg_Object_PLOTSETTINGS_printer_cfg_file_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_size_set", _wrap_Dwg_Object_PLOTSETTINGS_paper_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_size_get", _wrap_Dwg_Object_PLOTSETTINGS_paper_size_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_canonical_media_name_set", _wrap_Dwg_Object_PLOTSETTINGS_canonical_media_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_canonical_media_name_get", _wrap_Dwg_Object_PLOTSETTINGS_canonical_media_name_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_flags_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_flags_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_flags_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plotview_set", _wrap_Dwg_Object_PLOTSETTINGS_plotview_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plotview_get", _wrap_Dwg_Object_PLOTSETTINGS_plotview_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plotview_name_set", _wrap_Dwg_Object_PLOTSETTINGS_plotview_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plotview_name_get", _wrap_Dwg_Object_PLOTSETTINGS_plotview_name_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_left_margin_set", _wrap_Dwg_Object_PLOTSETTINGS_left_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_left_margin_get", _wrap_Dwg_Object_PLOTSETTINGS_left_margin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_bottom_margin_set", _wrap_Dwg_Object_PLOTSETTINGS_bottom_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_bottom_margin_get", _wrap_Dwg_Object_PLOTSETTINGS_bottom_margin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_right_margin_set", _wrap_Dwg_Object_PLOTSETTINGS_right_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_right_margin_get", _wrap_Dwg_Object_PLOTSETTINGS_right_margin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_top_margin_set", _wrap_Dwg_Object_PLOTSETTINGS_top_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_top_margin_get", _wrap_Dwg_Object_PLOTSETTINGS_top_margin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_width_set", _wrap_Dwg_Object_PLOTSETTINGS_paper_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_width_get", _wrap_Dwg_Object_PLOTSETTINGS_paper_width_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_height_set", _wrap_Dwg_Object_PLOTSETTINGS_paper_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_height_get", _wrap_Dwg_Object_PLOTSETTINGS_paper_height_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_origin_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_origin_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_origin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_window_ll_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_window_ll_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_window_ll_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_window_ll_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_window_ur_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_window_ur_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_window_ur_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_window_ur_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_paper_unit_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_paper_unit_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_paper_unit_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_paper_unit_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_rotation_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_rotation_mode_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_rotation_mode_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_type_set", _wrap_Dwg_Object_PLOTSETTINGS_plot_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_plot_type_get", _wrap_Dwg_Object_PLOTSETTINGS_plot_type_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_units_set", _wrap_Dwg_Object_PLOTSETTINGS_paper_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_units_get", _wrap_Dwg_Object_PLOTSETTINGS_paper_units_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_drawing_units_set", _wrap_Dwg_Object_PLOTSETTINGS_drawing_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_drawing_units_get", _wrap_Dwg_Object_PLOTSETTINGS_drawing_units_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_stylesheet_set", _wrap_Dwg_Object_PLOTSETTINGS_stylesheet_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_stylesheet_get", _wrap_Dwg_Object_PLOTSETTINGS_stylesheet_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_std_scale_type_set", _wrap_Dwg_Object_PLOTSETTINGS_std_scale_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_std_scale_type_get", _wrap_Dwg_Object_PLOTSETTINGS_std_scale_type_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_std_scale_factor_set", _wrap_Dwg_Object_PLOTSETTINGS_std_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_std_scale_factor_get", _wrap_Dwg_Object_PLOTSETTINGS_std_scale_factor_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_image_origin_set", _wrap_Dwg_Object_PLOTSETTINGS_paper_image_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_paper_image_origin_get", _wrap_Dwg_Object_PLOTSETTINGS_paper_image_origin_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_type_set", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_type_get", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_type_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_get", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_reslevel_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_get", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_customdpi_get, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_set", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PLOTSETTINGS_shadeplot_get", _wrap_Dwg_Object_PLOTSETTINGS_shadeplot_get, METH_O, NULL},
	 { "new_Dwg_Object_PLOTSETTINGS", _wrap_new_Dwg_Object_PLOTSETTINGS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_PLOTSETTINGS", _wrap_delete_Dwg_Object_PLOTSETTINGS, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_swigregister", Dwg_Object_PLOTSETTINGS_swigregister, METH_O, NULL},
	 { "Dwg_Object_PLOTSETTINGS_swiginit", Dwg_Object_PLOTSETTINGS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_parent_set", _wrap_Dwg_Object_LAYOUT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_parent_get", _wrap_Dwg_Object_LAYOUT_parent_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_plotsettings_set", _wrap_Dwg_Object_LAYOUT_plotsettings_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_plotsettings_get", _wrap_Dwg_Object_LAYOUT_plotsettings_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_layout_name_set", _wrap_Dwg_Object_LAYOUT_layout_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_layout_name_get", _wrap_Dwg_Object_LAYOUT_layout_name_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_tab_order_set", _wrap_Dwg_Object_LAYOUT_tab_order_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_tab_order_get", _wrap_Dwg_Object_LAYOUT_tab_order_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_layout_flags_set", _wrap_Dwg_Object_LAYOUT_layout_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_layout_flags_get", _wrap_Dwg_Object_LAYOUT_layout_flags_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_INSBASE_set", _wrap_Dwg_Object_LAYOUT_INSBASE_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_INSBASE_get", _wrap_Dwg_Object_LAYOUT_INSBASE_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_LIMMIN_set", _wrap_Dwg_Object_LAYOUT_LIMMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_LIMMIN_get", _wrap_Dwg_Object_LAYOUT_LIMMIN_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_LIMMAX_set", _wrap_Dwg_Object_LAYOUT_LIMMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_LIMMAX_get", _wrap_Dwg_Object_LAYOUT_LIMMAX_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_UCSORG_set", _wrap_Dwg_Object_LAYOUT_UCSORG_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_UCSORG_get", _wrap_Dwg_Object_LAYOUT_UCSORG_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_UCSXDIR_set", _wrap_Dwg_Object_LAYOUT_UCSXDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_UCSXDIR_get", _wrap_Dwg_Object_LAYOUT_UCSXDIR_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_UCSYDIR_set", _wrap_Dwg_Object_LAYOUT_UCSYDIR_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_UCSYDIR_get", _wrap_Dwg_Object_LAYOUT_UCSYDIR_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_ucs_elevation_set", _wrap_Dwg_Object_LAYOUT_ucs_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_ucs_elevation_get", _wrap_Dwg_Object_LAYOUT_ucs_elevation_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_UCSORTHOVIEW_set", _wrap_Dwg_Object_LAYOUT_UCSORTHOVIEW_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_UCSORTHOVIEW_get", _wrap_Dwg_Object_LAYOUT_UCSORTHOVIEW_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_EXTMIN_set", _wrap_Dwg_Object_LAYOUT_EXTMIN_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_EXTMIN_get", _wrap_Dwg_Object_LAYOUT_EXTMIN_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_EXTMAX_set", _wrap_Dwg_Object_LAYOUT_EXTMAX_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_EXTMAX_get", _wrap_Dwg_Object_LAYOUT_EXTMAX_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_block_header_set", _wrap_Dwg_Object_LAYOUT_block_header_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_block_header_get", _wrap_Dwg_Object_LAYOUT_block_header_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_active_viewport_set", _wrap_Dwg_Object_LAYOUT_active_viewport_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_active_viewport_get", _wrap_Dwg_Object_LAYOUT_active_viewport_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_base_ucs_set", _wrap_Dwg_Object_LAYOUT_base_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_base_ucs_get", _wrap_Dwg_Object_LAYOUT_base_ucs_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_named_ucs_set", _wrap_Dwg_Object_LAYOUT_named_ucs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_named_ucs_get", _wrap_Dwg_Object_LAYOUT_named_ucs_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_num_viewports_set", _wrap_Dwg_Object_LAYOUT_num_viewports_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_num_viewports_get", _wrap_Dwg_Object_LAYOUT_num_viewports_get, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_viewports_set", _wrap_Dwg_Object_LAYOUT_viewports_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYOUT_viewports_get", _wrap_Dwg_Object_LAYOUT_viewports_get, METH_O, NULL},
	 { "new_Dwg_Object_LAYOUT", _wrap_new_Dwg_Object_LAYOUT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LAYOUT", _wrap_delete_Dwg_Object_LAYOUT, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_swigregister", Dwg_Object_LAYOUT_swigregister, METH_O, NULL},
	 { "Dwg_Object_LAYOUT_swiginit", Dwg_Object_LAYOUT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYVAR_parent_set", _wrap_Dwg_Object_DICTIONARYVAR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYVAR_parent_get", _wrap_Dwg_Object_DICTIONARYVAR_parent_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYVAR_schema_set", _wrap_Dwg_Object_DICTIONARYVAR_schema_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYVAR_schema_get", _wrap_Dwg_Object_DICTIONARYVAR_schema_get, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYVAR_strvalue_set", _wrap_Dwg_Object_DICTIONARYVAR_strvalue_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DICTIONARYVAR_strvalue_get", _wrap_Dwg_Object_DICTIONARYVAR_strvalue_get, METH_O, NULL},
	 { "new_Dwg_Object_DICTIONARYVAR", _wrap_new_Dwg_Object_DICTIONARYVAR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DICTIONARYVAR", _wrap_delete_Dwg_Object_DICTIONARYVAR, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYVAR_swigregister", Dwg_Object_DICTIONARYVAR_swigregister, METH_O, NULL},
	 { "Dwg_Object_DICTIONARYVAR_swiginit", Dwg_Object_DICTIONARYVAR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_flags_set", _wrap_Dwg_TABLE_value_flags_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_flags_get", _wrap_Dwg_TABLE_value_flags_get, METH_O, NULL},
	 { "Dwg_TABLE_value_format_flags_set", _wrap_Dwg_TABLE_value_format_flags_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_format_flags_get", _wrap_Dwg_TABLE_value_format_flags_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_type_set", _wrap_Dwg_TABLE_value_data_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_type_get", _wrap_Dwg_TABLE_value_data_type_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_size_set", _wrap_Dwg_TABLE_value_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_size_get", _wrap_Dwg_TABLE_value_data_size_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_long_set", _wrap_Dwg_TABLE_value_data_long_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_long_get", _wrap_Dwg_TABLE_value_data_long_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_double_set", _wrap_Dwg_TABLE_value_data_double_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_double_get", _wrap_Dwg_TABLE_value_data_double_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_string_set", _wrap_Dwg_TABLE_value_data_string_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_string_get", _wrap_Dwg_TABLE_value_data_string_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_date_set", _wrap_Dwg_TABLE_value_data_date_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_date_get", _wrap_Dwg_TABLE_value_data_date_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_point_set", _wrap_Dwg_TABLE_value_data_point_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_point_get", _wrap_Dwg_TABLE_value_data_point_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_3dpoint_set", _wrap_Dwg_TABLE_value_data_3dpoint_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_3dpoint_get", _wrap_Dwg_TABLE_value_data_3dpoint_get, METH_O, NULL},
	 { "Dwg_TABLE_value_data_handle_set", _wrap_Dwg_TABLE_value_data_handle_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_data_handle_get", _wrap_Dwg_TABLE_value_data_handle_get, METH_O, NULL},
	 { "Dwg_TABLE_value_unit_type_set", _wrap_Dwg_TABLE_value_unit_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_unit_type_get", _wrap_Dwg_TABLE_value_unit_type_get, METH_O, NULL},
	 { "Dwg_TABLE_value_format_string_set", _wrap_Dwg_TABLE_value_format_string_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_format_string_get", _wrap_Dwg_TABLE_value_format_string_get, METH_O, NULL},
	 { "Dwg_TABLE_value_value_string_set", _wrap_Dwg_TABLE_value_value_string_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_value_value_string_get", _wrap_Dwg_TABLE_value_value_string_get, METH_O, NULL},
	 { "new_Dwg_TABLE_value", _wrap_new_Dwg_TABLE_value, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_value", _wrap_delete_Dwg_TABLE_value, METH_O, NULL},
	 { "Dwg_TABLE_value_swigregister", Dwg_TABLE_value_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_value_swiginit", Dwg_TABLE_value_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_CustomDataItem_name_set", _wrap_Dwg_TABLE_CustomDataItem_name_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_CustomDataItem_name_get", _wrap_Dwg_TABLE_CustomDataItem_name_get, METH_O, NULL},
	 { "Dwg_TABLE_CustomDataItem_value_set", _wrap_Dwg_TABLE_CustomDataItem_value_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_CustomDataItem_value_get", _wrap_Dwg_TABLE_CustomDataItem_value_get, METH_O, NULL},
	 { "Dwg_TABLE_CustomDataItem_cell_parent_set", _wrap_Dwg_TABLE_CustomDataItem_cell_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_CustomDataItem_cell_parent_get", _wrap_Dwg_TABLE_CustomDataItem_cell_parent_get, METH_O, NULL},
	 { "Dwg_TABLE_CustomDataItem_row_parent_set", _wrap_Dwg_TABLE_CustomDataItem_row_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_CustomDataItem_row_parent_get", _wrap_Dwg_TABLE_CustomDataItem_row_parent_get, METH_O, NULL},
	 { "new_Dwg_TABLE_CustomDataItem", _wrap_new_Dwg_TABLE_CustomDataItem, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_CustomDataItem", _wrap_delete_Dwg_TABLE_CustomDataItem, METH_O, NULL},
	 { "Dwg_TABLE_CustomDataItem_swigregister", Dwg_TABLE_CustomDataItem_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_CustomDataItem_swiginit", Dwg_TABLE_CustomDataItem_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_AttrDef_parent_set", _wrap_Dwg_TABLE_AttrDef_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_AttrDef_parent_get", _wrap_Dwg_TABLE_AttrDef_parent_get, METH_O, NULL},
	 { "Dwg_TABLE_AttrDef_attdef_set", _wrap_Dwg_TABLE_AttrDef_attdef_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_AttrDef_attdef_get", _wrap_Dwg_TABLE_AttrDef_attdef_get, METH_O, NULL},
	 { "Dwg_TABLE_AttrDef_index_set", _wrap_Dwg_TABLE_AttrDef_index_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_AttrDef_index_get", _wrap_Dwg_TABLE_AttrDef_index_get, METH_O, NULL},
	 { "Dwg_TABLE_AttrDef_text_set", _wrap_Dwg_TABLE_AttrDef_text_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_AttrDef_text_get", _wrap_Dwg_TABLE_AttrDef_text_get, METH_O, NULL},
	 { "new_Dwg_TABLE_AttrDef", _wrap_new_Dwg_TABLE_AttrDef, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_AttrDef", _wrap_delete_Dwg_TABLE_AttrDef, METH_O, NULL},
	 { "Dwg_TABLE_AttrDef_swigregister", Dwg_TABLE_AttrDef_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_AttrDef_swiginit", Dwg_TABLE_AttrDef_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_parent_set", _wrap_Dwg_TABLE_Cell_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_parent_get", _wrap_Dwg_TABLE_Cell_parent_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_type_set", _wrap_Dwg_TABLE_Cell_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_type_get", _wrap_Dwg_TABLE_Cell_type_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_flags_set", _wrap_Dwg_TABLE_Cell_flags_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_flags_get", _wrap_Dwg_TABLE_Cell_flags_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_is_merged_value_set", _wrap_Dwg_TABLE_Cell_is_merged_value_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_is_merged_value_get", _wrap_Dwg_TABLE_Cell_is_merged_value_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_is_autofit_flag_set", _wrap_Dwg_TABLE_Cell_is_autofit_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_is_autofit_flag_get", _wrap_Dwg_TABLE_Cell_is_autofit_flag_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_merged_width_flag_set", _wrap_Dwg_TABLE_Cell_merged_width_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_merged_width_flag_get", _wrap_Dwg_TABLE_Cell_merged_width_flag_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_merged_height_flag_set", _wrap_Dwg_TABLE_Cell_merged_height_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_merged_height_flag_get", _wrap_Dwg_TABLE_Cell_merged_height_flag_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_rotation_set", _wrap_Dwg_TABLE_Cell_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_rotation_get", _wrap_Dwg_TABLE_Cell_rotation_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_text_value_set", _wrap_Dwg_TABLE_Cell_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_text_value_get", _wrap_Dwg_TABLE_Cell_text_value_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_text_style_set", _wrap_Dwg_TABLE_Cell_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_text_style_get", _wrap_Dwg_TABLE_Cell_text_style_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_block_handle_set", _wrap_Dwg_TABLE_Cell_block_handle_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_block_handle_get", _wrap_Dwg_TABLE_Cell_block_handle_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_block_scale_set", _wrap_Dwg_TABLE_Cell_block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_block_scale_get", _wrap_Dwg_TABLE_Cell_block_scale_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_additional_data_flag_set", _wrap_Dwg_TABLE_Cell_additional_data_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_additional_data_flag_get", _wrap_Dwg_TABLE_Cell_additional_data_flag_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_cell_flag_override_set", _wrap_Dwg_TABLE_Cell_cell_flag_override_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_cell_flag_override_get", _wrap_Dwg_TABLE_Cell_cell_flag_override_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_virtual_edge_flag_set", _wrap_Dwg_TABLE_Cell_virtual_edge_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_virtual_edge_flag_get", _wrap_Dwg_TABLE_Cell_virtual_edge_flag_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_cell_alignment_set", _wrap_Dwg_TABLE_Cell_cell_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_cell_alignment_get", _wrap_Dwg_TABLE_Cell_cell_alignment_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_bg_fill_none_set", _wrap_Dwg_TABLE_Cell_bg_fill_none_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_bg_fill_none_get", _wrap_Dwg_TABLE_Cell_bg_fill_none_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_bg_color_set", _wrap_Dwg_TABLE_Cell_bg_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_bg_color_get", _wrap_Dwg_TABLE_Cell_bg_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_content_color_set", _wrap_Dwg_TABLE_Cell_content_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_content_color_get", _wrap_Dwg_TABLE_Cell_content_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_text_height_set", _wrap_Dwg_TABLE_Cell_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_text_height_get", _wrap_Dwg_TABLE_Cell_text_height_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_top_grid_color_set", _wrap_Dwg_TABLE_Cell_top_grid_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_top_grid_color_get", _wrap_Dwg_TABLE_Cell_top_grid_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_top_grid_linewt_set", _wrap_Dwg_TABLE_Cell_top_grid_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_top_grid_linewt_get", _wrap_Dwg_TABLE_Cell_top_grid_linewt_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_top_visibility_set", _wrap_Dwg_TABLE_Cell_top_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_top_visibility_get", _wrap_Dwg_TABLE_Cell_top_visibility_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_right_grid_color_set", _wrap_Dwg_TABLE_Cell_right_grid_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_right_grid_color_get", _wrap_Dwg_TABLE_Cell_right_grid_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_right_grid_linewt_set", _wrap_Dwg_TABLE_Cell_right_grid_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_right_grid_linewt_get", _wrap_Dwg_TABLE_Cell_right_grid_linewt_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_right_visibility_set", _wrap_Dwg_TABLE_Cell_right_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_right_visibility_get", _wrap_Dwg_TABLE_Cell_right_visibility_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_bottom_grid_color_set", _wrap_Dwg_TABLE_Cell_bottom_grid_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_bottom_grid_color_get", _wrap_Dwg_TABLE_Cell_bottom_grid_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_bottom_grid_linewt_set", _wrap_Dwg_TABLE_Cell_bottom_grid_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_bottom_grid_linewt_get", _wrap_Dwg_TABLE_Cell_bottom_grid_linewt_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_bottom_visibility_set", _wrap_Dwg_TABLE_Cell_bottom_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_bottom_visibility_get", _wrap_Dwg_TABLE_Cell_bottom_visibility_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_left_grid_color_set", _wrap_Dwg_TABLE_Cell_left_grid_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_left_grid_color_get", _wrap_Dwg_TABLE_Cell_left_grid_color_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_left_grid_linewt_set", _wrap_Dwg_TABLE_Cell_left_grid_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_left_grid_linewt_get", _wrap_Dwg_TABLE_Cell_left_grid_linewt_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_left_visibility_set", _wrap_Dwg_TABLE_Cell_left_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_left_visibility_get", _wrap_Dwg_TABLE_Cell_left_visibility_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_unknown_set", _wrap_Dwg_TABLE_Cell_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_unknown_get", _wrap_Dwg_TABLE_Cell_unknown_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_value_set", _wrap_Dwg_TABLE_Cell_value_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_value_get", _wrap_Dwg_TABLE_Cell_value_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_num_attr_defs_set", _wrap_Dwg_TABLE_Cell_num_attr_defs_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_num_attr_defs_get", _wrap_Dwg_TABLE_Cell_num_attr_defs_get, METH_O, NULL},
	 { "Dwg_TABLE_Cell_attr_defs_set", _wrap_Dwg_TABLE_Cell_attr_defs_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_Cell_attr_defs_get", _wrap_Dwg_TABLE_Cell_attr_defs_get, METH_O, NULL},
	 { "new_Dwg_TABLE_Cell", _wrap_new_Dwg_TABLE_Cell, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_Cell", _wrap_delete_Dwg_TABLE_Cell, METH_O, NULL},
	 { "Dwg_TABLE_Cell_swigregister", Dwg_TABLE_Cell_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_Cell_swiginit", Dwg_TABLE_Cell_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakHeight_parent_set", _wrap_Dwg_TABLE_BreakHeight_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakHeight_parent_get", _wrap_Dwg_TABLE_BreakHeight_parent_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakHeight_position_set", _wrap_Dwg_TABLE_BreakHeight_position_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakHeight_position_get", _wrap_Dwg_TABLE_BreakHeight_position_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakHeight_height_set", _wrap_Dwg_TABLE_BreakHeight_height_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakHeight_height_get", _wrap_Dwg_TABLE_BreakHeight_height_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakHeight_flag_set", _wrap_Dwg_TABLE_BreakHeight_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakHeight_flag_get", _wrap_Dwg_TABLE_BreakHeight_flag_get, METH_O, NULL},
	 { "new_Dwg_TABLE_BreakHeight", _wrap_new_Dwg_TABLE_BreakHeight, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_BreakHeight", _wrap_delete_Dwg_TABLE_BreakHeight, METH_O, NULL},
	 { "Dwg_TABLE_BreakHeight_swigregister", Dwg_TABLE_BreakHeight_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_BreakHeight_swiginit", Dwg_TABLE_BreakHeight_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakRow_parent_set", _wrap_Dwg_TABLE_BreakRow_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakRow_parent_get", _wrap_Dwg_TABLE_BreakRow_parent_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakRow_position_set", _wrap_Dwg_TABLE_BreakRow_position_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakRow_position_get", _wrap_Dwg_TABLE_BreakRow_position_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakRow_start_set", _wrap_Dwg_TABLE_BreakRow_start_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakRow_start_get", _wrap_Dwg_TABLE_BreakRow_start_get, METH_O, NULL},
	 { "Dwg_TABLE_BreakRow_end_set", _wrap_Dwg_TABLE_BreakRow_end_set, METH_VARARGS, NULL},
	 { "Dwg_TABLE_BreakRow_end_get", _wrap_Dwg_TABLE_BreakRow_end_get, METH_O, NULL},
	 { "new_Dwg_TABLE_BreakRow", _wrap_new_Dwg_TABLE_BreakRow, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLE_BreakRow", _wrap_delete_Dwg_TABLE_BreakRow, METH_O, NULL},
	 { "Dwg_TABLE_BreakRow_swigregister", Dwg_TABLE_BreakRow_swigregister, METH_O, NULL},
	 { "Dwg_TABLE_BreakRow_swiginit", Dwg_TABLE_BreakRow_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LinkedData_name_set", _wrap_Dwg_LinkedData_name_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedData_name_get", _wrap_Dwg_LinkedData_name_get, METH_O, NULL},
	 { "Dwg_LinkedData_description_set", _wrap_Dwg_LinkedData_description_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedData_description_get", _wrap_Dwg_LinkedData_description_get, METH_O, NULL},
	 { "new_Dwg_LinkedData", _wrap_new_Dwg_LinkedData, METH_NOARGS, NULL},
	 { "delete_Dwg_LinkedData", _wrap_delete_Dwg_LinkedData, METH_O, NULL},
	 { "Dwg_LinkedData_swigregister", Dwg_LinkedData_swigregister, METH_O, NULL},
	 { "Dwg_LinkedData_swiginit", Dwg_LinkedData_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_Attr_parent_set", _wrap_Dwg_TableCellContent_Attr_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_Attr_parent_get", _wrap_Dwg_TableCellContent_Attr_parent_get, METH_O, NULL},
	 { "Dwg_TableCellContent_Attr_attdef_set", _wrap_Dwg_TableCellContent_Attr_attdef_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_Attr_attdef_get", _wrap_Dwg_TableCellContent_Attr_attdef_get, METH_O, NULL},
	 { "Dwg_TableCellContent_Attr_value_set", _wrap_Dwg_TableCellContent_Attr_value_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_Attr_value_get", _wrap_Dwg_TableCellContent_Attr_value_get, METH_O, NULL},
	 { "Dwg_TableCellContent_Attr_index_set", _wrap_Dwg_TableCellContent_Attr_index_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_Attr_index_get", _wrap_Dwg_TableCellContent_Attr_index_get, METH_O, NULL},
	 { "new_Dwg_TableCellContent_Attr", _wrap_new_Dwg_TableCellContent_Attr, METH_NOARGS, NULL},
	 { "delete_Dwg_TableCellContent_Attr", _wrap_delete_Dwg_TableCellContent_Attr, METH_O, NULL},
	 { "Dwg_TableCellContent_Attr_swigregister", Dwg_TableCellContent_Attr_swigregister, METH_O, NULL},
	 { "Dwg_TableCellContent_Attr_swiginit", Dwg_TableCellContent_Attr_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_property_override_flags_set", _wrap_Dwg_ContentFormat_property_override_flags_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_property_override_flags_get", _wrap_Dwg_ContentFormat_property_override_flags_get, METH_O, NULL},
	 { "Dwg_ContentFormat_property_flags_set", _wrap_Dwg_ContentFormat_property_flags_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_property_flags_get", _wrap_Dwg_ContentFormat_property_flags_get, METH_O, NULL},
	 { "Dwg_ContentFormat_value_data_type_set", _wrap_Dwg_ContentFormat_value_data_type_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_value_data_type_get", _wrap_Dwg_ContentFormat_value_data_type_get, METH_O, NULL},
	 { "Dwg_ContentFormat_value_unit_type_set", _wrap_Dwg_ContentFormat_value_unit_type_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_value_unit_type_get", _wrap_Dwg_ContentFormat_value_unit_type_get, METH_O, NULL},
	 { "Dwg_ContentFormat_value_format_string_set", _wrap_Dwg_ContentFormat_value_format_string_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_value_format_string_get", _wrap_Dwg_ContentFormat_value_format_string_get, METH_O, NULL},
	 { "Dwg_ContentFormat_rotation_set", _wrap_Dwg_ContentFormat_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_rotation_get", _wrap_Dwg_ContentFormat_rotation_get, METH_O, NULL},
	 { "Dwg_ContentFormat_block_scale_set", _wrap_Dwg_ContentFormat_block_scale_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_block_scale_get", _wrap_Dwg_ContentFormat_block_scale_get, METH_O, NULL},
	 { "Dwg_ContentFormat_cell_alignment_set", _wrap_Dwg_ContentFormat_cell_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_cell_alignment_get", _wrap_Dwg_ContentFormat_cell_alignment_get, METH_O, NULL},
	 { "Dwg_ContentFormat_content_color_set", _wrap_Dwg_ContentFormat_content_color_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_content_color_get", _wrap_Dwg_ContentFormat_content_color_get, METH_O, NULL},
	 { "Dwg_ContentFormat_text_style_set", _wrap_Dwg_ContentFormat_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_text_style_get", _wrap_Dwg_ContentFormat_text_style_get, METH_O, NULL},
	 { "Dwg_ContentFormat_text_height_set", _wrap_Dwg_ContentFormat_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_ContentFormat_text_height_get", _wrap_Dwg_ContentFormat_text_height_get, METH_O, NULL},
	 { "new_Dwg_ContentFormat", _wrap_new_Dwg_ContentFormat, METH_NOARGS, NULL},
	 { "delete_Dwg_ContentFormat", _wrap_delete_Dwg_ContentFormat, METH_O, NULL},
	 { "Dwg_ContentFormat_swigregister", Dwg_ContentFormat_swigregister, METH_O, NULL},
	 { "Dwg_ContentFormat_swiginit", Dwg_ContentFormat_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_parent_set", _wrap_Dwg_TableCellContent_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_parent_get", _wrap_Dwg_TableCellContent_parent_get, METH_O, NULL},
	 { "Dwg_TableCellContent_type_set", _wrap_Dwg_TableCellContent_type_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_type_get", _wrap_Dwg_TableCellContent_type_get, METH_O, NULL},
	 { "Dwg_TableCellContent_value_set", _wrap_Dwg_TableCellContent_value_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_value_get", _wrap_Dwg_TableCellContent_value_get, METH_O, NULL},
	 { "Dwg_TableCellContent_handle_set", _wrap_Dwg_TableCellContent_handle_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_handle_get", _wrap_Dwg_TableCellContent_handle_get, METH_O, NULL},
	 { "Dwg_TableCellContent_num_attrs_set", _wrap_Dwg_TableCellContent_num_attrs_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_num_attrs_get", _wrap_Dwg_TableCellContent_num_attrs_get, METH_O, NULL},
	 { "Dwg_TableCellContent_attrs_set", _wrap_Dwg_TableCellContent_attrs_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_attrs_get", _wrap_Dwg_TableCellContent_attrs_get, METH_O, NULL},
	 { "Dwg_TableCellContent_has_content_format_overrides_set", _wrap_Dwg_TableCellContent_has_content_format_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_has_content_format_overrides_get", _wrap_Dwg_TableCellContent_has_content_format_overrides_get, METH_O, NULL},
	 { "Dwg_TableCellContent_content_format_set", _wrap_Dwg_TableCellContent_content_format_set, METH_VARARGS, NULL},
	 { "Dwg_TableCellContent_content_format_get", _wrap_Dwg_TableCellContent_content_format_get, METH_O, NULL},
	 { "new_Dwg_TableCellContent", _wrap_new_Dwg_TableCellContent, METH_NOARGS, NULL},
	 { "delete_Dwg_TableCellContent", _wrap_delete_Dwg_TableCellContent, METH_O, NULL},
	 { "Dwg_TableCellContent_swigregister", Dwg_TableCellContent_swigregister, METH_O, NULL},
	 { "Dwg_TableCellContent_swiginit", Dwg_TableCellContent_swiginit, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_dist_top_left_set", _wrap_Dwg_CellContentGeometry_dist_top_left_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_dist_top_left_get", _wrap_Dwg_CellContentGeometry_dist_top_left_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_dist_center_set", _wrap_Dwg_CellContentGeometry_dist_center_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_dist_center_get", _wrap_Dwg_CellContentGeometry_dist_center_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_content_width_set", _wrap_Dwg_CellContentGeometry_content_width_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_content_width_get", _wrap_Dwg_CellContentGeometry_content_width_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_content_height_set", _wrap_Dwg_CellContentGeometry_content_height_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_content_height_get", _wrap_Dwg_CellContentGeometry_content_height_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_width_set", _wrap_Dwg_CellContentGeometry_width_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_width_get", _wrap_Dwg_CellContentGeometry_width_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_height_set", _wrap_Dwg_CellContentGeometry_height_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_height_get", _wrap_Dwg_CellContentGeometry_height_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_unknown_set", _wrap_Dwg_CellContentGeometry_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_unknown_get", _wrap_Dwg_CellContentGeometry_unknown_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_cell_parent_set", _wrap_Dwg_CellContentGeometry_cell_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_cell_parent_get", _wrap_Dwg_CellContentGeometry_cell_parent_get, METH_O, NULL},
	 { "Dwg_CellContentGeometry_geom_parent_set", _wrap_Dwg_CellContentGeometry_geom_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CellContentGeometry_geom_parent_get", _wrap_Dwg_CellContentGeometry_geom_parent_get, METH_O, NULL},
	 { "new_Dwg_CellContentGeometry", _wrap_new_Dwg_CellContentGeometry, METH_NOARGS, NULL},
	 { "delete_Dwg_CellContentGeometry", _wrap_delete_Dwg_CellContentGeometry, METH_O, NULL},
	 { "Dwg_CellContentGeometry_swigregister", Dwg_CellContentGeometry_swigregister, METH_O, NULL},
	 { "Dwg_CellContentGeometry_swiginit", Dwg_CellContentGeometry_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TableCell_flag_set", _wrap_Dwg_TableCell_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_flag_get", _wrap_Dwg_TableCell_flag_get, METH_O, NULL},
	 { "Dwg_TableCell_tooltip_set", _wrap_Dwg_TableCell_tooltip_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_tooltip_get", _wrap_Dwg_TableCell_tooltip_get, METH_O, NULL},
	 { "Dwg_TableCell_customdata_set", _wrap_Dwg_TableCell_customdata_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_customdata_get", _wrap_Dwg_TableCell_customdata_get, METH_O, NULL},
	 { "Dwg_TableCell_num_customdata_items_set", _wrap_Dwg_TableCell_num_customdata_items_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_num_customdata_items_get", _wrap_Dwg_TableCell_num_customdata_items_get, METH_O, NULL},
	 { "Dwg_TableCell_customdata_items_set", _wrap_Dwg_TableCell_customdata_items_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_customdata_items_get", _wrap_Dwg_TableCell_customdata_items_get, METH_O, NULL},
	 { "Dwg_TableCell_has_linked_data_set", _wrap_Dwg_TableCell_has_linked_data_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_has_linked_data_get", _wrap_Dwg_TableCell_has_linked_data_get, METH_O, NULL},
	 { "Dwg_TableCell_data_link_set", _wrap_Dwg_TableCell_data_link_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_data_link_get", _wrap_Dwg_TableCell_data_link_get, METH_O, NULL},
	 { "Dwg_TableCell_num_rows_set", _wrap_Dwg_TableCell_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_num_rows_get", _wrap_Dwg_TableCell_num_rows_get, METH_O, NULL},
	 { "Dwg_TableCell_num_cols_set", _wrap_Dwg_TableCell_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_num_cols_get", _wrap_Dwg_TableCell_num_cols_get, METH_O, NULL},
	 { "Dwg_TableCell_unknown_set", _wrap_Dwg_TableCell_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_unknown_get", _wrap_Dwg_TableCell_unknown_get, METH_O, NULL},
	 { "Dwg_TableCell_num_cell_contents_set", _wrap_Dwg_TableCell_num_cell_contents_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_num_cell_contents_get", _wrap_Dwg_TableCell_num_cell_contents_get, METH_O, NULL},
	 { "Dwg_TableCell_cell_contents_set", _wrap_Dwg_TableCell_cell_contents_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_cell_contents_get", _wrap_Dwg_TableCell_cell_contents_get, METH_O, NULL},
	 { "Dwg_TableCell_style_id_set", _wrap_Dwg_TableCell_style_id_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_style_id_get", _wrap_Dwg_TableCell_style_id_get, METH_O, NULL},
	 { "Dwg_TableCell_has_geom_data_set", _wrap_Dwg_TableCell_has_geom_data_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_has_geom_data_get", _wrap_Dwg_TableCell_has_geom_data_get, METH_O, NULL},
	 { "Dwg_TableCell_geom_data_flag_set", _wrap_Dwg_TableCell_geom_data_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_geom_data_flag_get", _wrap_Dwg_TableCell_geom_data_flag_get, METH_O, NULL},
	 { "Dwg_TableCell_width_w_gap_set", _wrap_Dwg_TableCell_width_w_gap_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_width_w_gap_get", _wrap_Dwg_TableCell_width_w_gap_get, METH_O, NULL},
	 { "Dwg_TableCell_height_w_gap_set", _wrap_Dwg_TableCell_height_w_gap_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_height_w_gap_get", _wrap_Dwg_TableCell_height_w_gap_get, METH_O, NULL},
	 { "Dwg_TableCell_tablegeometry_set", _wrap_Dwg_TableCell_tablegeometry_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_tablegeometry_get", _wrap_Dwg_TableCell_tablegeometry_get, METH_O, NULL},
	 { "Dwg_TableCell_num_geometry_set", _wrap_Dwg_TableCell_num_geometry_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_num_geometry_get", _wrap_Dwg_TableCell_num_geometry_get, METH_O, NULL},
	 { "Dwg_TableCell_geometry_set", _wrap_Dwg_TableCell_geometry_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_geometry_get", _wrap_Dwg_TableCell_geometry_get, METH_O, NULL},
	 { "Dwg_TableCell_style_parent_set", _wrap_Dwg_TableCell_style_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_style_parent_get", _wrap_Dwg_TableCell_style_parent_get, METH_O, NULL},
	 { "Dwg_TableCell_row_parent_set", _wrap_Dwg_TableCell_row_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableCell_row_parent_get", _wrap_Dwg_TableCell_row_parent_get, METH_O, NULL},
	 { "new_Dwg_TableCell", _wrap_new_Dwg_TableCell, METH_NOARGS, NULL},
	 { "delete_Dwg_TableCell", _wrap_delete_Dwg_TableCell, METH_O, NULL},
	 { "Dwg_TableCell_swigregister", Dwg_TableCell_swigregister, METH_O, NULL},
	 { "Dwg_TableCell_swiginit", Dwg_TableCell_swiginit, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_parent_set", _wrap_Dwg_GridFormat_parent_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_parent_get", _wrap_Dwg_GridFormat_parent_get, METH_O, NULL},
	 { "Dwg_GridFormat_index_mask_set", _wrap_Dwg_GridFormat_index_mask_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_index_mask_get", _wrap_Dwg_GridFormat_index_mask_get, METH_O, NULL},
	 { "Dwg_GridFormat_border_overrides_set", _wrap_Dwg_GridFormat_border_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_border_overrides_get", _wrap_Dwg_GridFormat_border_overrides_get, METH_O, NULL},
	 { "Dwg_GridFormat_border_type_set", _wrap_Dwg_GridFormat_border_type_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_border_type_get", _wrap_Dwg_GridFormat_border_type_get, METH_O, NULL},
	 { "Dwg_GridFormat_color_set", _wrap_Dwg_GridFormat_color_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_color_get", _wrap_Dwg_GridFormat_color_get, METH_O, NULL},
	 { "Dwg_GridFormat_linewt_set", _wrap_Dwg_GridFormat_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_linewt_get", _wrap_Dwg_GridFormat_linewt_get, METH_O, NULL},
	 { "Dwg_GridFormat_ltype_set", _wrap_Dwg_GridFormat_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_ltype_get", _wrap_Dwg_GridFormat_ltype_get, METH_O, NULL},
	 { "Dwg_GridFormat_visible_set", _wrap_Dwg_GridFormat_visible_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_visible_get", _wrap_Dwg_GridFormat_visible_get, METH_O, NULL},
	 { "Dwg_GridFormat_double_line_spacing_set", _wrap_Dwg_GridFormat_double_line_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_GridFormat_double_line_spacing_get", _wrap_Dwg_GridFormat_double_line_spacing_get, METH_O, NULL},
	 { "new_Dwg_GridFormat", _wrap_new_Dwg_GridFormat, METH_NOARGS, NULL},
	 { "delete_Dwg_GridFormat", _wrap_delete_Dwg_GridFormat, METH_O, NULL},
	 { "Dwg_GridFormat_swigregister", Dwg_GridFormat_swigregister, METH_O, NULL},
	 { "Dwg_GridFormat_swiginit", Dwg_GridFormat_swiginit, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_type_set", _wrap_Dwg_CellStyle_type_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_type_get", _wrap_Dwg_CellStyle_type_get, METH_O, NULL},
	 { "Dwg_CellStyle_data_flags_set", _wrap_Dwg_CellStyle_data_flags_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_data_flags_get", _wrap_Dwg_CellStyle_data_flags_get, METH_O, NULL},
	 { "Dwg_CellStyle_property_override_flags_set", _wrap_Dwg_CellStyle_property_override_flags_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_property_override_flags_get", _wrap_Dwg_CellStyle_property_override_flags_get, METH_O, NULL},
	 { "Dwg_CellStyle_merge_flags_set", _wrap_Dwg_CellStyle_merge_flags_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_merge_flags_get", _wrap_Dwg_CellStyle_merge_flags_get, METH_O, NULL},
	 { "Dwg_CellStyle_bg_color_set", _wrap_Dwg_CellStyle_bg_color_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_bg_color_get", _wrap_Dwg_CellStyle_bg_color_get, METH_O, NULL},
	 { "Dwg_CellStyle_content_layout_set", _wrap_Dwg_CellStyle_content_layout_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_content_layout_get", _wrap_Dwg_CellStyle_content_layout_get, METH_O, NULL},
	 { "Dwg_CellStyle_content_format_set", _wrap_Dwg_CellStyle_content_format_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_content_format_get", _wrap_Dwg_CellStyle_content_format_get, METH_O, NULL},
	 { "Dwg_CellStyle_margin_override_flags_set", _wrap_Dwg_CellStyle_margin_override_flags_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_margin_override_flags_get", _wrap_Dwg_CellStyle_margin_override_flags_get, METH_O, NULL},
	 { "Dwg_CellStyle_vert_margin_set", _wrap_Dwg_CellStyle_vert_margin_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_vert_margin_get", _wrap_Dwg_CellStyle_vert_margin_get, METH_O, NULL},
	 { "Dwg_CellStyle_horiz_margin_set", _wrap_Dwg_CellStyle_horiz_margin_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_horiz_margin_get", _wrap_Dwg_CellStyle_horiz_margin_get, METH_O, NULL},
	 { "Dwg_CellStyle_bottom_margin_set", _wrap_Dwg_CellStyle_bottom_margin_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_bottom_margin_get", _wrap_Dwg_CellStyle_bottom_margin_get, METH_O, NULL},
	 { "Dwg_CellStyle_right_margin_set", _wrap_Dwg_CellStyle_right_margin_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_right_margin_get", _wrap_Dwg_CellStyle_right_margin_get, METH_O, NULL},
	 { "Dwg_CellStyle_margin_horiz_spacing_set", _wrap_Dwg_CellStyle_margin_horiz_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_margin_horiz_spacing_get", _wrap_Dwg_CellStyle_margin_horiz_spacing_get, METH_O, NULL},
	 { "Dwg_CellStyle_margin_vert_spacing_set", _wrap_Dwg_CellStyle_margin_vert_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_margin_vert_spacing_get", _wrap_Dwg_CellStyle_margin_vert_spacing_get, METH_O, NULL},
	 { "Dwg_CellStyle_num_borders_set", _wrap_Dwg_CellStyle_num_borders_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_num_borders_get", _wrap_Dwg_CellStyle_num_borders_get, METH_O, NULL},
	 { "Dwg_CellStyle_borders_set", _wrap_Dwg_CellStyle_borders_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_borders_get", _wrap_Dwg_CellStyle_borders_get, METH_O, NULL},
	 { "Dwg_CellStyle_tablerow_parent_set", _wrap_Dwg_CellStyle_tablerow_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_tablerow_parent_get", _wrap_Dwg_CellStyle_tablerow_parent_get, METH_O, NULL},
	 { "Dwg_CellStyle_tabledatacolumn_parent_set", _wrap_Dwg_CellStyle_tabledatacolumn_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CellStyle_tabledatacolumn_parent_get", _wrap_Dwg_CellStyle_tabledatacolumn_parent_get, METH_O, NULL},
	 { "new_Dwg_CellStyle", _wrap_new_Dwg_CellStyle, METH_NOARGS, NULL},
	 { "delete_Dwg_CellStyle", _wrap_delete_Dwg_CellStyle, METH_O, NULL},
	 { "Dwg_CellStyle_swigregister", Dwg_CellStyle_swigregister, METH_O, NULL},
	 { "Dwg_CellStyle_swiginit", Dwg_CellStyle_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TableRow_parent_set", _wrap_Dwg_TableRow_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_parent_get", _wrap_Dwg_TableRow_parent_get, METH_O, NULL},
	 { "Dwg_TableRow_num_cells_set", _wrap_Dwg_TableRow_num_cells_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_num_cells_get", _wrap_Dwg_TableRow_num_cells_get, METH_O, NULL},
	 { "Dwg_TableRow_cells_set", _wrap_Dwg_TableRow_cells_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_cells_get", _wrap_Dwg_TableRow_cells_get, METH_O, NULL},
	 { "Dwg_TableRow_custom_data_set", _wrap_Dwg_TableRow_custom_data_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_custom_data_get", _wrap_Dwg_TableRow_custom_data_get, METH_O, NULL},
	 { "Dwg_TableRow_num_customdata_items_set", _wrap_Dwg_TableRow_num_customdata_items_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_num_customdata_items_get", _wrap_Dwg_TableRow_num_customdata_items_get, METH_O, NULL},
	 { "Dwg_TableRow_customdata_items_set", _wrap_Dwg_TableRow_customdata_items_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_customdata_items_get", _wrap_Dwg_TableRow_customdata_items_get, METH_O, NULL},
	 { "Dwg_TableRow_cellstyle_set", _wrap_Dwg_TableRow_cellstyle_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_cellstyle_get", _wrap_Dwg_TableRow_cellstyle_get, METH_O, NULL},
	 { "Dwg_TableRow_style_id_set", _wrap_Dwg_TableRow_style_id_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_style_id_get", _wrap_Dwg_TableRow_style_id_get, METH_O, NULL},
	 { "Dwg_TableRow_height_set", _wrap_Dwg_TableRow_height_set, METH_VARARGS, NULL},
	 { "Dwg_TableRow_height_get", _wrap_Dwg_TableRow_height_get, METH_O, NULL},
	 { "new_Dwg_TableRow", _wrap_new_Dwg_TableRow, METH_NOARGS, NULL},
	 { "delete_Dwg_TableRow", _wrap_delete_Dwg_TableRow, METH_O, NULL},
	 { "Dwg_TableRow_swigregister", Dwg_TableRow_swigregister, METH_O, NULL},
	 { "Dwg_TableRow_swiginit", Dwg_TableRow_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_parent_set", _wrap_Dwg_TableDataColumn_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_parent_get", _wrap_Dwg_TableDataColumn_parent_get, METH_O, NULL},
	 { "Dwg_TableDataColumn_name_set", _wrap_Dwg_TableDataColumn_name_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_name_get", _wrap_Dwg_TableDataColumn_name_get, METH_O, NULL},
	 { "Dwg_TableDataColumn_custom_data_set", _wrap_Dwg_TableDataColumn_custom_data_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_custom_data_get", _wrap_Dwg_TableDataColumn_custom_data_get, METH_O, NULL},
	 { "Dwg_TableDataColumn_cellstyle_set", _wrap_Dwg_TableDataColumn_cellstyle_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_cellstyle_get", _wrap_Dwg_TableDataColumn_cellstyle_get, METH_O, NULL},
	 { "Dwg_TableDataColumn_cellstyle_id_set", _wrap_Dwg_TableDataColumn_cellstyle_id_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_cellstyle_id_get", _wrap_Dwg_TableDataColumn_cellstyle_id_get, METH_O, NULL},
	 { "Dwg_TableDataColumn_width_set", _wrap_Dwg_TableDataColumn_width_set, METH_VARARGS, NULL},
	 { "Dwg_TableDataColumn_width_get", _wrap_Dwg_TableDataColumn_width_get, METH_O, NULL},
	 { "new_Dwg_TableDataColumn", _wrap_new_Dwg_TableDataColumn, METH_NOARGS, NULL},
	 { "delete_Dwg_TableDataColumn", _wrap_delete_Dwg_TableDataColumn, METH_O, NULL},
	 { "Dwg_TableDataColumn_swigregister", Dwg_TableDataColumn_swigregister, METH_O, NULL},
	 { "Dwg_TableDataColumn_swiginit", Dwg_TableDataColumn_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_num_cols_set", _wrap_Dwg_LinkedTableData_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_num_cols_get", _wrap_Dwg_LinkedTableData_num_cols_get, METH_O, NULL},
	 { "Dwg_LinkedTableData_cols_set", _wrap_Dwg_LinkedTableData_cols_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_cols_get", _wrap_Dwg_LinkedTableData_cols_get, METH_O, NULL},
	 { "Dwg_LinkedTableData_num_rows_set", _wrap_Dwg_LinkedTableData_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_num_rows_get", _wrap_Dwg_LinkedTableData_num_rows_get, METH_O, NULL},
	 { "Dwg_LinkedTableData_rows_set", _wrap_Dwg_LinkedTableData_rows_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_rows_get", _wrap_Dwg_LinkedTableData_rows_get, METH_O, NULL},
	 { "Dwg_LinkedTableData_num_field_refs_set", _wrap_Dwg_LinkedTableData_num_field_refs_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_num_field_refs_get", _wrap_Dwg_LinkedTableData_num_field_refs_get, METH_O, NULL},
	 { "Dwg_LinkedTableData_field_refs_set", _wrap_Dwg_LinkedTableData_field_refs_set, METH_VARARGS, NULL},
	 { "Dwg_LinkedTableData_field_refs_get", _wrap_Dwg_LinkedTableData_field_refs_get, METH_O, NULL},
	 { "new_Dwg_LinkedTableData", _wrap_new_Dwg_LinkedTableData, METH_NOARGS, NULL},
	 { "delete_Dwg_LinkedTableData", _wrap_delete_Dwg_LinkedTableData, METH_O, NULL},
	 { "Dwg_LinkedTableData_swigregister", Dwg_LinkedTableData_swigregister, METH_O, NULL},
	 { "Dwg_LinkedTableData_swiginit", Dwg_LinkedTableData_swiginit, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_parent_set", _wrap_Dwg_FormattedTableMerged_parent_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_parent_get", _wrap_Dwg_FormattedTableMerged_parent_get, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_top_row_set", _wrap_Dwg_FormattedTableMerged_top_row_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_top_row_get", _wrap_Dwg_FormattedTableMerged_top_row_get, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_left_col_set", _wrap_Dwg_FormattedTableMerged_left_col_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_left_col_get", _wrap_Dwg_FormattedTableMerged_left_col_get, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_bottom_row_set", _wrap_Dwg_FormattedTableMerged_bottom_row_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_bottom_row_get", _wrap_Dwg_FormattedTableMerged_bottom_row_get, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_right_col_set", _wrap_Dwg_FormattedTableMerged_right_col_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableMerged_right_col_get", _wrap_Dwg_FormattedTableMerged_right_col_get, METH_O, NULL},
	 { "new_Dwg_FormattedTableMerged", _wrap_new_Dwg_FormattedTableMerged, METH_NOARGS, NULL},
	 { "delete_Dwg_FormattedTableMerged", _wrap_delete_Dwg_FormattedTableMerged, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_swigregister", Dwg_FormattedTableMerged_swigregister, METH_O, NULL},
	 { "Dwg_FormattedTableMerged_swiginit", Dwg_FormattedTableMerged_swiginit, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableData_parent_set", _wrap_Dwg_FormattedTableData_parent_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableData_parent_get", _wrap_Dwg_FormattedTableData_parent_get, METH_O, NULL},
	 { "Dwg_FormattedTableData_cellstyle_set", _wrap_Dwg_FormattedTableData_cellstyle_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableData_cellstyle_get", _wrap_Dwg_FormattedTableData_cellstyle_get, METH_O, NULL},
	 { "Dwg_FormattedTableData_num_merged_cells_set", _wrap_Dwg_FormattedTableData_num_merged_cells_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableData_num_merged_cells_get", _wrap_Dwg_FormattedTableData_num_merged_cells_get, METH_O, NULL},
	 { "Dwg_FormattedTableData_merged_cells_set", _wrap_Dwg_FormattedTableData_merged_cells_set, METH_VARARGS, NULL},
	 { "Dwg_FormattedTableData_merged_cells_get", _wrap_Dwg_FormattedTableData_merged_cells_get, METH_O, NULL},
	 { "new_Dwg_FormattedTableData", _wrap_new_Dwg_FormattedTableData, METH_NOARGS, NULL},
	 { "delete_Dwg_FormattedTableData", _wrap_delete_Dwg_FormattedTableData, METH_O, NULL},
	 { "Dwg_FormattedTableData_swigregister", Dwg_FormattedTableData_swigregister, METH_O, NULL},
	 { "Dwg_FormattedTableData_swiginit", Dwg_FormattedTableData_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_parent_set", _wrap_Dwg_Object_TABLECONTENT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_parent_get", _wrap_Dwg_Object_TABLECONTENT_parent_get, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_ldata_set", _wrap_Dwg_Object_TABLECONTENT_ldata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_ldata_get", _wrap_Dwg_Object_TABLECONTENT_ldata_get, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_tdata_set", _wrap_Dwg_Object_TABLECONTENT_tdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_tdata_get", _wrap_Dwg_Object_TABLECONTENT_tdata_get, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_fdata_set", _wrap_Dwg_Object_TABLECONTENT_fdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_fdata_get", _wrap_Dwg_Object_TABLECONTENT_fdata_get, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_tablestyle_set", _wrap_Dwg_Object_TABLECONTENT_tablestyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLECONTENT_tablestyle_get", _wrap_Dwg_Object_TABLECONTENT_tablestyle_get, METH_O, NULL},
	 { "new_Dwg_Object_TABLECONTENT", _wrap_new_Dwg_Object_TABLECONTENT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_TABLECONTENT", _wrap_delete_Dwg_Object_TABLECONTENT, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_swigregister", Dwg_Object_TABLECONTENT_swigregister, METH_O, NULL},
	 { "Dwg_Object_TABLECONTENT_swiginit", Dwg_Object_TABLECONTENT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_parent_set", _wrap_Dwg_Entity_TABLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_parent_get", _wrap_Dwg_Entity_TABLE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_ldata_set", _wrap_Dwg_Entity_TABLE_ldata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_ldata_get", _wrap_Dwg_Entity_TABLE_ldata_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_tdata_set", _wrap_Dwg_Entity_TABLE_tdata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_tdata_get", _wrap_Dwg_Entity_TABLE_tdata_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_fdata_set", _wrap_Dwg_Entity_TABLE_fdata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_fdata_get", _wrap_Dwg_Entity_TABLE_fdata_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_tablestyle_set", _wrap_Dwg_Entity_TABLE_tablestyle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_tablestyle_get", _wrap_Dwg_Entity_TABLE_tablestyle_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_rc_set", _wrap_Dwg_Entity_TABLE_unknown_rc_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_rc_get", _wrap_Dwg_Entity_TABLE_unknown_rc_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_h_set", _wrap_Dwg_Entity_TABLE_unknown_h_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_h_get", _wrap_Dwg_Entity_TABLE_unknown_h_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_bl_set", _wrap_Dwg_Entity_TABLE_unknown_bl_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_bl_get", _wrap_Dwg_Entity_TABLE_unknown_bl_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_b_set", _wrap_Dwg_Entity_TABLE_unknown_b_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_b_get", _wrap_Dwg_Entity_TABLE_unknown_b_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_bl1_set", _wrap_Dwg_Entity_TABLE_unknown_bl1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_bl1_get", _wrap_Dwg_Entity_TABLE_unknown_bl1_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_ins_pt_set", _wrap_Dwg_Entity_TABLE_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_ins_pt_get", _wrap_Dwg_Entity_TABLE_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_scale_set", _wrap_Dwg_Entity_TABLE_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_scale_get", _wrap_Dwg_Entity_TABLE_scale_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_scale_flag_set", _wrap_Dwg_Entity_TABLE_scale_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_scale_flag_get", _wrap_Dwg_Entity_TABLE_scale_flag_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_rotation_set", _wrap_Dwg_Entity_TABLE_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_rotation_get", _wrap_Dwg_Entity_TABLE_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_extrusion_set", _wrap_Dwg_Entity_TABLE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_extrusion_get", _wrap_Dwg_Entity_TABLE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_attribs_set", _wrap_Dwg_Entity_TABLE_has_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_attribs_get", _wrap_Dwg_Entity_TABLE_has_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_owned_set", _wrap_Dwg_Entity_TABLE_num_owned_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_owned_get", _wrap_Dwg_Entity_TABLE_num_owned_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_flag_for_table_value_set", _wrap_Dwg_Entity_TABLE_flag_for_table_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_flag_for_table_value_get", _wrap_Dwg_Entity_TABLE_flag_for_table_value_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_horiz_direction_set", _wrap_Dwg_Entity_TABLE_horiz_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_horiz_direction_get", _wrap_Dwg_Entity_TABLE_horiz_direction_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_cols_set", _wrap_Dwg_Entity_TABLE_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_cols_get", _wrap_Dwg_Entity_TABLE_num_cols_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_rows_set", _wrap_Dwg_Entity_TABLE_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_rows_get", _wrap_Dwg_Entity_TABLE_num_rows_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_cells_set", _wrap_Dwg_Entity_TABLE_num_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_cells_get", _wrap_Dwg_Entity_TABLE_num_cells_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_col_widths_set", _wrap_Dwg_Entity_TABLE_col_widths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_col_widths_get", _wrap_Dwg_Entity_TABLE_col_widths_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_row_heights_set", _wrap_Dwg_Entity_TABLE_row_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_row_heights_get", _wrap_Dwg_Entity_TABLE_row_heights_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_cells_set", _wrap_Dwg_Entity_TABLE_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_cells_get", _wrap_Dwg_Entity_TABLE_cells_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_table_overrides_set", _wrap_Dwg_Entity_TABLE_has_table_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_table_overrides_get", _wrap_Dwg_Entity_TABLE_has_table_overrides_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_table_flag_override_set", _wrap_Dwg_Entity_TABLE_table_flag_override_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_table_flag_override_get", _wrap_Dwg_Entity_TABLE_table_flag_override_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_suppressed_set", _wrap_Dwg_Entity_TABLE_title_suppressed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_suppressed_get", _wrap_Dwg_Entity_TABLE_title_suppressed_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_suppressed_set", _wrap_Dwg_Entity_TABLE_header_suppressed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_suppressed_get", _wrap_Dwg_Entity_TABLE_header_suppressed_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_flow_direction_set", _wrap_Dwg_Entity_TABLE_flow_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_flow_direction_get", _wrap_Dwg_Entity_TABLE_flow_direction_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_horiz_cell_margin_set", _wrap_Dwg_Entity_TABLE_horiz_cell_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_horiz_cell_margin_get", _wrap_Dwg_Entity_TABLE_horiz_cell_margin_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_vert_cell_margin_set", _wrap_Dwg_Entity_TABLE_vert_cell_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_vert_cell_margin_get", _wrap_Dwg_Entity_TABLE_vert_cell_margin_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_color_set", _wrap_Dwg_Entity_TABLE_title_row_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_color_get", _wrap_Dwg_Entity_TABLE_title_row_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_color_set", _wrap_Dwg_Entity_TABLE_header_row_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_color_get", _wrap_Dwg_Entity_TABLE_header_row_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_color_set", _wrap_Dwg_Entity_TABLE_data_row_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_color_get", _wrap_Dwg_Entity_TABLE_data_row_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_fill_none_set", _wrap_Dwg_Entity_TABLE_title_row_fill_none_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_fill_none_get", _wrap_Dwg_Entity_TABLE_title_row_fill_none_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_fill_none_set", _wrap_Dwg_Entity_TABLE_header_row_fill_none_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_fill_none_get", _wrap_Dwg_Entity_TABLE_header_row_fill_none_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_fill_none_set", _wrap_Dwg_Entity_TABLE_data_row_fill_none_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_fill_none_get", _wrap_Dwg_Entity_TABLE_data_row_fill_none_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_fill_color_set", _wrap_Dwg_Entity_TABLE_title_row_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_fill_color_get", _wrap_Dwg_Entity_TABLE_title_row_fill_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_fill_color_set", _wrap_Dwg_Entity_TABLE_header_row_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_fill_color_get", _wrap_Dwg_Entity_TABLE_header_row_fill_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_fill_color_set", _wrap_Dwg_Entity_TABLE_data_row_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_fill_color_get", _wrap_Dwg_Entity_TABLE_data_row_fill_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_alignment_set", _wrap_Dwg_Entity_TABLE_title_row_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_alignment_get", _wrap_Dwg_Entity_TABLE_title_row_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_alignment_set", _wrap_Dwg_Entity_TABLE_header_row_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_alignment_get", _wrap_Dwg_Entity_TABLE_header_row_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_alignment_set", _wrap_Dwg_Entity_TABLE_data_row_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_alignment_get", _wrap_Dwg_Entity_TABLE_data_row_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_text_style_set", _wrap_Dwg_Entity_TABLE_title_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_text_style_get", _wrap_Dwg_Entity_TABLE_title_text_style_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_text_style_set", _wrap_Dwg_Entity_TABLE_header_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_text_style_get", _wrap_Dwg_Entity_TABLE_header_text_style_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_text_style_set", _wrap_Dwg_Entity_TABLE_data_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_text_style_get", _wrap_Dwg_Entity_TABLE_data_text_style_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_height_set", _wrap_Dwg_Entity_TABLE_title_row_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_height_get", _wrap_Dwg_Entity_TABLE_title_row_height_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_height_set", _wrap_Dwg_Entity_TABLE_header_row_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_height_get", _wrap_Dwg_Entity_TABLE_header_row_height_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_height_set", _wrap_Dwg_Entity_TABLE_data_row_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_height_get", _wrap_Dwg_Entity_TABLE_data_row_height_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_border_color_overrides_set", _wrap_Dwg_Entity_TABLE_has_border_color_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_border_color_overrides_get", _wrap_Dwg_Entity_TABLE_has_border_color_overrides_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_border_color_overrides_flag_set", _wrap_Dwg_Entity_TABLE_border_color_overrides_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_border_color_overrides_flag_get", _wrap_Dwg_Entity_TABLE_border_color_overrides_flag_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_color_set", _wrap_Dwg_Entity_TABLE_title_horiz_top_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_color_get", _wrap_Dwg_Entity_TABLE_title_horiz_top_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_color_set", _wrap_Dwg_Entity_TABLE_title_horiz_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_color_get", _wrap_Dwg_Entity_TABLE_title_horiz_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_color_set", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_color_get", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_color_set", _wrap_Dwg_Entity_TABLE_title_vert_left_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_color_get", _wrap_Dwg_Entity_TABLE_title_vert_left_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_color_set", _wrap_Dwg_Entity_TABLE_title_vert_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_color_get", _wrap_Dwg_Entity_TABLE_title_vert_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_color_set", _wrap_Dwg_Entity_TABLE_title_vert_right_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_color_get", _wrap_Dwg_Entity_TABLE_title_vert_right_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_color_set", _wrap_Dwg_Entity_TABLE_header_horiz_top_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_color_get", _wrap_Dwg_Entity_TABLE_header_horiz_top_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_color_set", _wrap_Dwg_Entity_TABLE_header_horiz_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_color_get", _wrap_Dwg_Entity_TABLE_header_horiz_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_color_set", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_color_get", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_color_set", _wrap_Dwg_Entity_TABLE_header_vert_left_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_color_get", _wrap_Dwg_Entity_TABLE_header_vert_left_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_color_set", _wrap_Dwg_Entity_TABLE_header_vert_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_color_get", _wrap_Dwg_Entity_TABLE_header_vert_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_color_set", _wrap_Dwg_Entity_TABLE_header_vert_right_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_color_get", _wrap_Dwg_Entity_TABLE_header_vert_right_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_color_set", _wrap_Dwg_Entity_TABLE_data_horiz_top_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_color_get", _wrap_Dwg_Entity_TABLE_data_horiz_top_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_color_set", _wrap_Dwg_Entity_TABLE_data_horiz_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_color_get", _wrap_Dwg_Entity_TABLE_data_horiz_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_color_set", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_color_get", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_color_set", _wrap_Dwg_Entity_TABLE_data_vert_left_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_color_get", _wrap_Dwg_Entity_TABLE_data_vert_left_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_color_set", _wrap_Dwg_Entity_TABLE_data_vert_ins_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_color_get", _wrap_Dwg_Entity_TABLE_data_vert_ins_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_color_set", _wrap_Dwg_Entity_TABLE_data_vert_right_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_color_get", _wrap_Dwg_Entity_TABLE_data_vert_right_color_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_border_lineweight_overrides_set", _wrap_Dwg_Entity_TABLE_has_border_lineweight_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_border_lineweight_overrides_get", _wrap_Dwg_Entity_TABLE_has_border_lineweight_overrides_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_border_lineweight_overrides_flag_set", _wrap_Dwg_Entity_TABLE_border_lineweight_overrides_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_border_lineweight_overrides_flag_get", _wrap_Dwg_Entity_TABLE_border_lineweight_overrides_flag_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_linewt_set", _wrap_Dwg_Entity_TABLE_title_horiz_top_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_linewt_get", _wrap_Dwg_Entity_TABLE_title_horiz_top_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_linewt_set", _wrap_Dwg_Entity_TABLE_title_horiz_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_linewt_get", _wrap_Dwg_Entity_TABLE_title_horiz_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_linewt_set", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_linewt_get", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_linewt_set", _wrap_Dwg_Entity_TABLE_title_vert_left_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_linewt_get", _wrap_Dwg_Entity_TABLE_title_vert_left_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_linewt_set", _wrap_Dwg_Entity_TABLE_title_vert_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_linewt_get", _wrap_Dwg_Entity_TABLE_title_vert_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_linewt_set", _wrap_Dwg_Entity_TABLE_title_vert_right_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_linewt_get", _wrap_Dwg_Entity_TABLE_title_vert_right_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_linewt_set", _wrap_Dwg_Entity_TABLE_header_horiz_top_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_linewt_get", _wrap_Dwg_Entity_TABLE_header_horiz_top_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_linewt_set", _wrap_Dwg_Entity_TABLE_header_horiz_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_linewt_get", _wrap_Dwg_Entity_TABLE_header_horiz_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_linewt_set", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_linewt_get", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_linewt_set", _wrap_Dwg_Entity_TABLE_header_vert_left_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_linewt_get", _wrap_Dwg_Entity_TABLE_header_vert_left_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_linewt_set", _wrap_Dwg_Entity_TABLE_header_vert_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_linewt_get", _wrap_Dwg_Entity_TABLE_header_vert_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_linewt_set", _wrap_Dwg_Entity_TABLE_header_vert_right_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_linewt_get", _wrap_Dwg_Entity_TABLE_header_vert_right_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_linewt_set", _wrap_Dwg_Entity_TABLE_data_horiz_top_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_linewt_get", _wrap_Dwg_Entity_TABLE_data_horiz_top_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_linewt_set", _wrap_Dwg_Entity_TABLE_data_horiz_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_linewt_get", _wrap_Dwg_Entity_TABLE_data_horiz_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_linewt_set", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_linewt_get", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_linewt_set", _wrap_Dwg_Entity_TABLE_data_vert_left_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_linewt_get", _wrap_Dwg_Entity_TABLE_data_vert_left_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_linewt_set", _wrap_Dwg_Entity_TABLE_data_vert_ins_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_linewt_get", _wrap_Dwg_Entity_TABLE_data_vert_ins_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_linewt_set", _wrap_Dwg_Entity_TABLE_data_vert_right_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_linewt_get", _wrap_Dwg_Entity_TABLE_data_vert_right_linewt_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_border_visibility_overrides_set", _wrap_Dwg_Entity_TABLE_has_border_visibility_overrides_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_border_visibility_overrides_get", _wrap_Dwg_Entity_TABLE_has_border_visibility_overrides_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_border_visibility_overrides_flag_set", _wrap_Dwg_Entity_TABLE_border_visibility_overrides_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_border_visibility_overrides_flag_get", _wrap_Dwg_Entity_TABLE_border_visibility_overrides_flag_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_visibility_set", _wrap_Dwg_Entity_TABLE_title_horiz_top_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_top_visibility_get", _wrap_Dwg_Entity_TABLE_title_horiz_top_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_visibility_set", _wrap_Dwg_Entity_TABLE_title_horiz_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_ins_visibility_get", _wrap_Dwg_Entity_TABLE_title_horiz_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_visibility_set", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_horiz_bottom_visibility_get", _wrap_Dwg_Entity_TABLE_title_horiz_bottom_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_visibility_set", _wrap_Dwg_Entity_TABLE_title_vert_left_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_left_visibility_get", _wrap_Dwg_Entity_TABLE_title_vert_left_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_visibility_set", _wrap_Dwg_Entity_TABLE_title_vert_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_ins_visibility_get", _wrap_Dwg_Entity_TABLE_title_vert_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_visibility_set", _wrap_Dwg_Entity_TABLE_title_vert_right_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_vert_right_visibility_get", _wrap_Dwg_Entity_TABLE_title_vert_right_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_visibility_set", _wrap_Dwg_Entity_TABLE_header_horiz_top_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_top_visibility_get", _wrap_Dwg_Entity_TABLE_header_horiz_top_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_visibility_set", _wrap_Dwg_Entity_TABLE_header_horiz_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_ins_visibility_get", _wrap_Dwg_Entity_TABLE_header_horiz_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_visibility_set", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_horiz_bottom_visibility_get", _wrap_Dwg_Entity_TABLE_header_horiz_bottom_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_visibility_set", _wrap_Dwg_Entity_TABLE_header_vert_left_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_left_visibility_get", _wrap_Dwg_Entity_TABLE_header_vert_left_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_visibility_set", _wrap_Dwg_Entity_TABLE_header_vert_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_ins_visibility_get", _wrap_Dwg_Entity_TABLE_header_vert_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_visibility_set", _wrap_Dwg_Entity_TABLE_header_vert_right_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_vert_right_visibility_get", _wrap_Dwg_Entity_TABLE_header_vert_right_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_visibility_set", _wrap_Dwg_Entity_TABLE_data_horiz_top_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_top_visibility_get", _wrap_Dwg_Entity_TABLE_data_horiz_top_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_visibility_set", _wrap_Dwg_Entity_TABLE_data_horiz_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_ins_visibility_get", _wrap_Dwg_Entity_TABLE_data_horiz_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_visibility_set", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_horiz_bottom_visibility_get", _wrap_Dwg_Entity_TABLE_data_horiz_bottom_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_visibility_set", _wrap_Dwg_Entity_TABLE_data_vert_left_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_left_visibility_get", _wrap_Dwg_Entity_TABLE_data_vert_left_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_visibility_set", _wrap_Dwg_Entity_TABLE_data_vert_ins_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_ins_visibility_get", _wrap_Dwg_Entity_TABLE_data_vert_ins_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_visibility_set", _wrap_Dwg_Entity_TABLE_data_vert_right_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_vert_right_visibility_get", _wrap_Dwg_Entity_TABLE_data_vert_right_visibility_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_block_header_set", _wrap_Dwg_Entity_TABLE_block_header_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_block_header_get", _wrap_Dwg_Entity_TABLE_block_header_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_first_attrib_set", _wrap_Dwg_Entity_TABLE_first_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_first_attrib_get", _wrap_Dwg_Entity_TABLE_first_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_last_attrib_set", _wrap_Dwg_Entity_TABLE_last_attrib_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_last_attrib_get", _wrap_Dwg_Entity_TABLE_last_attrib_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_attribs_set", _wrap_Dwg_Entity_TABLE_attribs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_attribs_get", _wrap_Dwg_Entity_TABLE_attribs_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_seqend_set", _wrap_Dwg_Entity_TABLE_seqend_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_seqend_get", _wrap_Dwg_Entity_TABLE_seqend_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_title_row_style_override_set", _wrap_Dwg_Entity_TABLE_title_row_style_override_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_title_row_style_override_get", _wrap_Dwg_Entity_TABLE_title_row_style_override_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_header_row_style_override_set", _wrap_Dwg_Entity_TABLE_header_row_style_override_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_header_row_style_override_get", _wrap_Dwg_Entity_TABLE_header_row_style_override_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_data_row_style_override_set", _wrap_Dwg_Entity_TABLE_data_row_style_override_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_data_row_style_override_get", _wrap_Dwg_Entity_TABLE_data_row_style_override_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_unknown_bs_set", _wrap_Dwg_Entity_TABLE_unknown_bs_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_unknown_bs_get", _wrap_Dwg_Entity_TABLE_unknown_bs_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_hor_dir_set", _wrap_Dwg_Entity_TABLE_hor_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_hor_dir_get", _wrap_Dwg_Entity_TABLE_hor_dir_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_has_break_data_set", _wrap_Dwg_Entity_TABLE_has_break_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_has_break_data_get", _wrap_Dwg_Entity_TABLE_has_break_data_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_flag_set", _wrap_Dwg_Entity_TABLE_break_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_flag_get", _wrap_Dwg_Entity_TABLE_break_flag_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_flow_direction_set", _wrap_Dwg_Entity_TABLE_break_flow_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_flow_direction_get", _wrap_Dwg_Entity_TABLE_break_flow_direction_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_spacing_set", _wrap_Dwg_Entity_TABLE_break_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_spacing_get", _wrap_Dwg_Entity_TABLE_break_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_unknown1_set", _wrap_Dwg_Entity_TABLE_break_unknown1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_unknown1_get", _wrap_Dwg_Entity_TABLE_break_unknown1_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_unknown2_set", _wrap_Dwg_Entity_TABLE_break_unknown2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_unknown2_get", _wrap_Dwg_Entity_TABLE_break_unknown2_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_break_heights_set", _wrap_Dwg_Entity_TABLE_num_break_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_break_heights_get", _wrap_Dwg_Entity_TABLE_num_break_heights_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_heights_set", _wrap_Dwg_Entity_TABLE_break_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_heights_get", _wrap_Dwg_Entity_TABLE_break_heights_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_num_break_rows_set", _wrap_Dwg_Entity_TABLE_num_break_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_num_break_rows_get", _wrap_Dwg_Entity_TABLE_num_break_rows_get, METH_O, NULL},
	 { "Dwg_Entity_TABLE_break_rows_set", _wrap_Dwg_Entity_TABLE_break_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_TABLE_break_rows_get", _wrap_Dwg_Entity_TABLE_break_rows_get, METH_O, NULL},
	 { "new_Dwg_Entity_TABLE", _wrap_new_Dwg_Entity_TABLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_TABLE", _wrap_delete_Dwg_Entity_TABLE, METH_O, NULL},
	 { "Dwg_Entity_TABLE_swigregister", Dwg_Entity_TABLE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_TABLE_swiginit", Dwg_Entity_TABLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_parent_set", _wrap_Dwg_TABLESTYLE_CellStyle_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_parent_get", _wrap_Dwg_TABLESTYLE_CellStyle_parent_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_id_set", _wrap_Dwg_TABLESTYLE_CellStyle_id_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_id_get", _wrap_Dwg_TABLESTYLE_CellStyle_id_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_type_set", _wrap_Dwg_TABLESTYLE_CellStyle_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_type_get", _wrap_Dwg_TABLESTYLE_CellStyle_type_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_name_set", _wrap_Dwg_TABLESTYLE_CellStyle_name_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_name_get", _wrap_Dwg_TABLESTYLE_CellStyle_name_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_cellstyle_set", _wrap_Dwg_TABLESTYLE_CellStyle_cellstyle_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_cellstyle_get", _wrap_Dwg_TABLESTYLE_CellStyle_cellstyle_get, METH_O, NULL},
	 { "new_Dwg_TABLESTYLE_CellStyle", _wrap_new_Dwg_TABLESTYLE_CellStyle, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLESTYLE_CellStyle", _wrap_delete_Dwg_TABLESTYLE_CellStyle, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_swigregister", Dwg_TABLESTYLE_CellStyle_swigregister, METH_O, NULL},
	 { "Dwg_TABLESTYLE_CellStyle_swiginit", Dwg_TABLESTYLE_CellStyle_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_border_linewt_set", _wrap_Dwg_TABLESTYLE_border_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_border_linewt_get", _wrap_Dwg_TABLESTYLE_border_linewt_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_border_visible_set", _wrap_Dwg_TABLESTYLE_border_visible_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_border_visible_get", _wrap_Dwg_TABLESTYLE_border_visible_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_border_color_set", _wrap_Dwg_TABLESTYLE_border_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_border_color_get", _wrap_Dwg_TABLESTYLE_border_color_get, METH_O, NULL},
	 { "new_Dwg_TABLESTYLE_border", _wrap_new_Dwg_TABLESTYLE_border, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLESTYLE_border", _wrap_delete_Dwg_TABLESTYLE_border, METH_O, NULL},
	 { "Dwg_TABLESTYLE_border_swigregister", Dwg_TABLESTYLE_border_swigregister, METH_O, NULL},
	 { "Dwg_TABLESTYLE_border_swiginit", Dwg_TABLESTYLE_border_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_parent_set", _wrap_Dwg_TABLESTYLE_rowstyles_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_parent_get", _wrap_Dwg_TABLESTYLE_rowstyles_parent_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_style_set", _wrap_Dwg_TABLESTYLE_rowstyles_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_style_get", _wrap_Dwg_TABLESTYLE_rowstyles_text_style_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_height_set", _wrap_Dwg_TABLESTYLE_rowstyles_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_height_get", _wrap_Dwg_TABLESTYLE_rowstyles_text_height_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_alignment_set", _wrap_Dwg_TABLESTYLE_rowstyles_text_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_alignment_get", _wrap_Dwg_TABLESTYLE_rowstyles_text_alignment_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_color_set", _wrap_Dwg_TABLESTYLE_rowstyles_text_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_text_color_get", _wrap_Dwg_TABLESTYLE_rowstyles_text_color_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_fill_color_set", _wrap_Dwg_TABLESTYLE_rowstyles_fill_color_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_fill_color_get", _wrap_Dwg_TABLESTYLE_rowstyles_fill_color_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_has_bgcolor_set", _wrap_Dwg_TABLESTYLE_rowstyles_has_bgcolor_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_has_bgcolor_get", _wrap_Dwg_TABLESTYLE_rowstyles_has_bgcolor_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_num_borders_set", _wrap_Dwg_TABLESTYLE_rowstyles_num_borders_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_num_borders_get", _wrap_Dwg_TABLESTYLE_rowstyles_num_borders_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_borders_set", _wrap_Dwg_TABLESTYLE_rowstyles_borders_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_borders_get", _wrap_Dwg_TABLESTYLE_rowstyles_borders_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_data_type_set", _wrap_Dwg_TABLESTYLE_rowstyles_data_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_data_type_get", _wrap_Dwg_TABLESTYLE_rowstyles_data_type_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_unit_type_set", _wrap_Dwg_TABLESTYLE_rowstyles_unit_type_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_unit_type_get", _wrap_Dwg_TABLESTYLE_rowstyles_unit_type_get, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_format_string_set", _wrap_Dwg_TABLESTYLE_rowstyles_format_string_set, METH_VARARGS, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_format_string_get", _wrap_Dwg_TABLESTYLE_rowstyles_format_string_get, METH_O, NULL},
	 { "new_Dwg_TABLESTYLE_rowstyles", _wrap_new_Dwg_TABLESTYLE_rowstyles, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLESTYLE_rowstyles", _wrap_delete_Dwg_TABLESTYLE_rowstyles, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_swigregister", Dwg_TABLESTYLE_rowstyles_swigregister, METH_O, NULL},
	 { "Dwg_TABLESTYLE_rowstyles_swiginit", Dwg_TABLESTYLE_rowstyles_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_parent_set", _wrap_Dwg_Object_TABLESTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_parent_get", _wrap_Dwg_Object_TABLESTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_class_version_set", _wrap_Dwg_Object_TABLESTYLE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_class_version_get", _wrap_Dwg_Object_TABLESTYLE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_name_set", _wrap_Dwg_Object_TABLESTYLE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_name_get", _wrap_Dwg_Object_TABLESTYLE_name_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_flags_set", _wrap_Dwg_Object_TABLESTYLE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_flags_get", _wrap_Dwg_Object_TABLESTYLE_flags_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_flow_direction_set", _wrap_Dwg_Object_TABLESTYLE_flow_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_flow_direction_get", _wrap_Dwg_Object_TABLESTYLE_flow_direction_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_horiz_cell_margin_set", _wrap_Dwg_Object_TABLESTYLE_horiz_cell_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_horiz_cell_margin_get", _wrap_Dwg_Object_TABLESTYLE_horiz_cell_margin_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_vert_cell_margin_set", _wrap_Dwg_Object_TABLESTYLE_vert_cell_margin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_vert_cell_margin_get", _wrap_Dwg_Object_TABLESTYLE_vert_cell_margin_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_is_title_suppressed_set", _wrap_Dwg_Object_TABLESTYLE_is_title_suppressed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_is_title_suppressed_get", _wrap_Dwg_Object_TABLESTYLE_is_title_suppressed_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_is_header_suppressed_set", _wrap_Dwg_Object_TABLESTYLE_is_header_suppressed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_is_header_suppressed_get", _wrap_Dwg_Object_TABLESTYLE_is_header_suppressed_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_rc_set", _wrap_Dwg_Object_TABLESTYLE_unknown_rc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_rc_get", _wrap_Dwg_Object_TABLESTYLE_unknown_rc_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl1_set", _wrap_Dwg_Object_TABLESTYLE_unknown_bl1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl1_get", _wrap_Dwg_Object_TABLESTYLE_unknown_bl1_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl2_set", _wrap_Dwg_Object_TABLESTYLE_unknown_bl2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl2_get", _wrap_Dwg_Object_TABLESTYLE_unknown_bl2_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_cellstyle_set", _wrap_Dwg_Object_TABLESTYLE_cellstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_cellstyle_get", _wrap_Dwg_Object_TABLESTYLE_cellstyle_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_sty_set", _wrap_Dwg_Object_TABLESTYLE_sty_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_sty_get", _wrap_Dwg_Object_TABLESTYLE_sty_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_numoverrides_set", _wrap_Dwg_Object_TABLESTYLE_numoverrides_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_numoverrides_get", _wrap_Dwg_Object_TABLESTYLE_numoverrides_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl3_set", _wrap_Dwg_Object_TABLESTYLE_unknown_bl3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_unknown_bl3_get", _wrap_Dwg_Object_TABLESTYLE_unknown_bl3_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_ovr_set", _wrap_Dwg_Object_TABLESTYLE_ovr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_ovr_get", _wrap_Dwg_Object_TABLESTYLE_ovr_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_num_rowstyles_set", _wrap_Dwg_Object_TABLESTYLE_num_rowstyles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_num_rowstyles_get", _wrap_Dwg_Object_TABLESTYLE_num_rowstyles_get, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_rowstyles_set", _wrap_Dwg_Object_TABLESTYLE_rowstyles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLESTYLE_rowstyles_get", _wrap_Dwg_Object_TABLESTYLE_rowstyles_get, METH_O, NULL},
	 { "new_Dwg_Object_TABLESTYLE", _wrap_new_Dwg_Object_TABLESTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_TABLESTYLE", _wrap_delete_Dwg_Object_TABLESTYLE, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_swigregister", Dwg_Object_TABLESTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_TABLESTYLE_swiginit", Dwg_Object_TABLESTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_parent_set", _wrap_Dwg_Object_CELLSTYLEMAP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_parent_get", _wrap_Dwg_Object_CELLSTYLEMAP_parent_get, METH_O, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_num_cells_set", _wrap_Dwg_Object_CELLSTYLEMAP_num_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_num_cells_get", _wrap_Dwg_Object_CELLSTYLEMAP_num_cells_get, METH_O, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_cells_set", _wrap_Dwg_Object_CELLSTYLEMAP_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_cells_get", _wrap_Dwg_Object_CELLSTYLEMAP_cells_get, METH_O, NULL},
	 { "new_Dwg_Object_CELLSTYLEMAP", _wrap_new_Dwg_Object_CELLSTYLEMAP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_CELLSTYLEMAP", _wrap_delete_Dwg_Object_CELLSTYLEMAP, METH_O, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_swigregister", Dwg_Object_CELLSTYLEMAP_swigregister, METH_O, NULL},
	 { "Dwg_Object_CELLSTYLEMAP_swiginit", Dwg_Object_CELLSTYLEMAP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_parent_set", _wrap_Dwg_TABLEGEOMETRY_Cell_parent_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_parent_get", _wrap_Dwg_TABLEGEOMETRY_Cell_parent_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set", _wrap_Dwg_TABLEGEOMETRY_Cell_geom_data_flag_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_geom_data_flag_get", _wrap_Dwg_TABLEGEOMETRY_Cell_geom_data_flag_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_width_w_gap_set", _wrap_Dwg_TABLEGEOMETRY_Cell_width_w_gap_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_width_w_gap_get", _wrap_Dwg_TABLEGEOMETRY_Cell_width_w_gap_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_height_w_gap_set", _wrap_Dwg_TABLEGEOMETRY_Cell_height_w_gap_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_height_w_gap_get", _wrap_Dwg_TABLEGEOMETRY_Cell_height_w_gap_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_tablegeometry_set", _wrap_Dwg_TABLEGEOMETRY_Cell_tablegeometry_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_tablegeometry_get", _wrap_Dwg_TABLEGEOMETRY_Cell_tablegeometry_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_num_geometry_set", _wrap_Dwg_TABLEGEOMETRY_Cell_num_geometry_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_num_geometry_get", _wrap_Dwg_TABLEGEOMETRY_Cell_num_geometry_get, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_geometry_set", _wrap_Dwg_TABLEGEOMETRY_Cell_geometry_set, METH_VARARGS, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_geometry_get", _wrap_Dwg_TABLEGEOMETRY_Cell_geometry_get, METH_O, NULL},
	 { "new_Dwg_TABLEGEOMETRY_Cell", _wrap_new_Dwg_TABLEGEOMETRY_Cell, METH_NOARGS, NULL},
	 { "delete_Dwg_TABLEGEOMETRY_Cell", _wrap_delete_Dwg_TABLEGEOMETRY_Cell, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_swigregister", Dwg_TABLEGEOMETRY_Cell_swigregister, METH_O, NULL},
	 { "Dwg_TABLEGEOMETRY_Cell_swiginit", Dwg_TABLEGEOMETRY_Cell_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_parent_set", _wrap_Dwg_Object_TABLEGEOMETRY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_parent_get", _wrap_Dwg_Object_TABLEGEOMETRY_parent_get, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_numrows_set", _wrap_Dwg_Object_TABLEGEOMETRY_numrows_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_numrows_get", _wrap_Dwg_Object_TABLEGEOMETRY_numrows_get, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_numcols_set", _wrap_Dwg_Object_TABLEGEOMETRY_numcols_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_numcols_get", _wrap_Dwg_Object_TABLEGEOMETRY_numcols_get, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_num_cells_set", _wrap_Dwg_Object_TABLEGEOMETRY_num_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_num_cells_get", _wrap_Dwg_Object_TABLEGEOMETRY_num_cells_get, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_cells_set", _wrap_Dwg_Object_TABLEGEOMETRY_cells_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_cells_get", _wrap_Dwg_Object_TABLEGEOMETRY_cells_get, METH_O, NULL},
	 { "new_Dwg_Object_TABLEGEOMETRY", _wrap_new_Dwg_Object_TABLEGEOMETRY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_TABLEGEOMETRY", _wrap_delete_Dwg_Object_TABLEGEOMETRY, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_swigregister", Dwg_Object_TABLEGEOMETRY_swigregister, METH_O, NULL},
	 { "Dwg_Object_TABLEGEOMETRY_swiginit", Dwg_Object_TABLEGEOMETRY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_parent_set", _wrap_Dwg_Object_UNDERLAYDEFINITION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_parent_get", _wrap_Dwg_Object_UNDERLAYDEFINITION_parent_get, METH_O, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_filename_set", _wrap_Dwg_Object_UNDERLAYDEFINITION_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_filename_get", _wrap_Dwg_Object_UNDERLAYDEFINITION_filename_get, METH_O, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_name_set", _wrap_Dwg_Object_UNDERLAYDEFINITION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_name_get", _wrap_Dwg_Object_UNDERLAYDEFINITION_name_get, METH_O, NULL},
	 { "new_Dwg_Object_UNDERLAYDEFINITION", _wrap_new_Dwg_Object_UNDERLAYDEFINITION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_UNDERLAYDEFINITION", _wrap_delete_Dwg_Object_UNDERLAYDEFINITION, METH_O, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_swigregister", Dwg_Object_UNDERLAYDEFINITION_swigregister, METH_O, NULL},
	 { "Dwg_Object_UNDERLAYDEFINITION_swiginit", Dwg_Object_UNDERLAYDEFINITION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_parent_set", _wrap_Dwg_Entity_UNDERLAY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_parent_get", _wrap_Dwg_Entity_UNDERLAY_parent_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_extrusion_set", _wrap_Dwg_Entity_UNDERLAY_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_extrusion_get", _wrap_Dwg_Entity_UNDERLAY_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_ins_pt_set", _wrap_Dwg_Entity_UNDERLAY_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_ins_pt_get", _wrap_Dwg_Entity_UNDERLAY_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_scale_set", _wrap_Dwg_Entity_UNDERLAY_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_scale_get", _wrap_Dwg_Entity_UNDERLAY_scale_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_angle_set", _wrap_Dwg_Entity_UNDERLAY_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_angle_get", _wrap_Dwg_Entity_UNDERLAY_angle_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_flag_set", _wrap_Dwg_Entity_UNDERLAY_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_flag_get", _wrap_Dwg_Entity_UNDERLAY_flag_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_contrast_set", _wrap_Dwg_Entity_UNDERLAY_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_contrast_get", _wrap_Dwg_Entity_UNDERLAY_contrast_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_fade_set", _wrap_Dwg_Entity_UNDERLAY_fade_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_fade_get", _wrap_Dwg_Entity_UNDERLAY_fade_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_num_clip_verts_set", _wrap_Dwg_Entity_UNDERLAY_num_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_num_clip_verts_get", _wrap_Dwg_Entity_UNDERLAY_num_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_clip_verts_set", _wrap_Dwg_Entity_UNDERLAY_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_clip_verts_get", _wrap_Dwg_Entity_UNDERLAY_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_num_clip_inverts_set", _wrap_Dwg_Entity_UNDERLAY_num_clip_inverts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_num_clip_inverts_get", _wrap_Dwg_Entity_UNDERLAY_num_clip_inverts_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_clip_inverts_set", _wrap_Dwg_Entity_UNDERLAY_clip_inverts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_clip_inverts_get", _wrap_Dwg_Entity_UNDERLAY_clip_inverts_get, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_definition_id_set", _wrap_Dwg_Entity_UNDERLAY_definition_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNDERLAY_definition_id_get", _wrap_Dwg_Entity_UNDERLAY_definition_id_get, METH_O, NULL},
	 { "new_Dwg_Entity_UNDERLAY", _wrap_new_Dwg_Entity_UNDERLAY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_UNDERLAY", _wrap_delete_Dwg_Entity_UNDERLAY, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_swigregister", Dwg_Entity_UNDERLAY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_UNDERLAY_swiginit", Dwg_Entity_UNDERLAY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DBCOLOR_parent_set", _wrap_Dwg_Object_DBCOLOR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DBCOLOR_parent_get", _wrap_Dwg_Object_DBCOLOR_parent_get, METH_O, NULL},
	 { "Dwg_Object_DBCOLOR_color_set", _wrap_Dwg_Object_DBCOLOR_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DBCOLOR_color_get", _wrap_Dwg_Object_DBCOLOR_color_get, METH_O, NULL},
	 { "new_Dwg_Object_DBCOLOR", _wrap_new_Dwg_Object_DBCOLOR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DBCOLOR", _wrap_delete_Dwg_Object_DBCOLOR, METH_O, NULL},
	 { "Dwg_Object_DBCOLOR_swigregister", Dwg_Object_DBCOLOR_swigregister, METH_O, NULL},
	 { "Dwg_Object_DBCOLOR_swiginit", Dwg_Object_DBCOLOR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_FIELD_ChildValue_parent_set", _wrap_Dwg_FIELD_ChildValue_parent_set, METH_VARARGS, NULL},
	 { "Dwg_FIELD_ChildValue_parent_get", _wrap_Dwg_FIELD_ChildValue_parent_get, METH_O, NULL},
	 { "Dwg_FIELD_ChildValue_key_set", _wrap_Dwg_FIELD_ChildValue_key_set, METH_VARARGS, NULL},
	 { "Dwg_FIELD_ChildValue_key_get", _wrap_Dwg_FIELD_ChildValue_key_get, METH_O, NULL},
	 { "Dwg_FIELD_ChildValue_value_set", _wrap_Dwg_FIELD_ChildValue_value_set, METH_VARARGS, NULL},
	 { "Dwg_FIELD_ChildValue_value_get", _wrap_Dwg_FIELD_ChildValue_value_get, METH_O, NULL},
	 { "new_Dwg_FIELD_ChildValue", _wrap_new_Dwg_FIELD_ChildValue, METH_NOARGS, NULL},
	 { "delete_Dwg_FIELD_ChildValue", _wrap_delete_Dwg_FIELD_ChildValue, METH_O, NULL},
	 { "Dwg_FIELD_ChildValue_swigregister", Dwg_FIELD_ChildValue_swigregister, METH_O, NULL},
	 { "Dwg_FIELD_ChildValue_swiginit", Dwg_FIELD_ChildValue_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_parent_set", _wrap_Dwg_Object_FIELD_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_parent_get", _wrap_Dwg_Object_FIELD_parent_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_id_set", _wrap_Dwg_Object_FIELD_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_id_get", _wrap_Dwg_Object_FIELD_id_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_code_set", _wrap_Dwg_Object_FIELD_code_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_code_get", _wrap_Dwg_Object_FIELD_code_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_num_childs_set", _wrap_Dwg_Object_FIELD_num_childs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_num_childs_get", _wrap_Dwg_Object_FIELD_num_childs_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_childs_set", _wrap_Dwg_Object_FIELD_childs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_childs_get", _wrap_Dwg_Object_FIELD_childs_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_num_objects_set", _wrap_Dwg_Object_FIELD_num_objects_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_num_objects_get", _wrap_Dwg_Object_FIELD_num_objects_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_objects_set", _wrap_Dwg_Object_FIELD_objects_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_objects_get", _wrap_Dwg_Object_FIELD_objects_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_format_set", _wrap_Dwg_Object_FIELD_format_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_format_get", _wrap_Dwg_Object_FIELD_format_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_evaluation_option_set", _wrap_Dwg_Object_FIELD_evaluation_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_evaluation_option_get", _wrap_Dwg_Object_FIELD_evaluation_option_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_filing_option_set", _wrap_Dwg_Object_FIELD_filing_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_filing_option_get", _wrap_Dwg_Object_FIELD_filing_option_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_field_state_set", _wrap_Dwg_Object_FIELD_field_state_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_field_state_get", _wrap_Dwg_Object_FIELD_field_state_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_evaluation_status_set", _wrap_Dwg_Object_FIELD_evaluation_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_evaluation_status_get", _wrap_Dwg_Object_FIELD_evaluation_status_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_evaluation_error_code_set", _wrap_Dwg_Object_FIELD_evaluation_error_code_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_evaluation_error_code_get", _wrap_Dwg_Object_FIELD_evaluation_error_code_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_evaluation_error_msg_set", _wrap_Dwg_Object_FIELD_evaluation_error_msg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_evaluation_error_msg_get", _wrap_Dwg_Object_FIELD_evaluation_error_msg_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_value_set", _wrap_Dwg_Object_FIELD_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_value_get", _wrap_Dwg_Object_FIELD_value_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_value_string_set", _wrap_Dwg_Object_FIELD_value_string_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_value_string_get", _wrap_Dwg_Object_FIELD_value_string_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_value_string_length_set", _wrap_Dwg_Object_FIELD_value_string_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_value_string_length_get", _wrap_Dwg_Object_FIELD_value_string_length_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_num_childval_set", _wrap_Dwg_Object_FIELD_num_childval_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_num_childval_get", _wrap_Dwg_Object_FIELD_num_childval_get, METH_O, NULL},
	 { "Dwg_Object_FIELD_childval_set", _wrap_Dwg_Object_FIELD_childval_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELD_childval_get", _wrap_Dwg_Object_FIELD_childval_get, METH_O, NULL},
	 { "new_Dwg_Object_FIELD", _wrap_new_Dwg_Object_FIELD, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_FIELD", _wrap_delete_Dwg_Object_FIELD, METH_O, NULL},
	 { "Dwg_Object_FIELD_swigregister", Dwg_Object_FIELD_swigregister, METH_O, NULL},
	 { "Dwg_Object_FIELD_swiginit", Dwg_Object_FIELD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELDLIST_parent_set", _wrap_Dwg_Object_FIELDLIST_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELDLIST_parent_get", _wrap_Dwg_Object_FIELDLIST_parent_get, METH_O, NULL},
	 { "Dwg_Object_FIELDLIST_num_fields_set", _wrap_Dwg_Object_FIELDLIST_num_fields_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELDLIST_num_fields_get", _wrap_Dwg_Object_FIELDLIST_num_fields_get, METH_O, NULL},
	 { "Dwg_Object_FIELDLIST_unknown_set", _wrap_Dwg_Object_FIELDLIST_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELDLIST_unknown_get", _wrap_Dwg_Object_FIELDLIST_unknown_get, METH_O, NULL},
	 { "Dwg_Object_FIELDLIST_fields_set", _wrap_Dwg_Object_FIELDLIST_fields_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FIELDLIST_fields_get", _wrap_Dwg_Object_FIELDLIST_fields_get, METH_O, NULL},
	 { "new_Dwg_Object_FIELDLIST", _wrap_new_Dwg_Object_FIELDLIST, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_FIELDLIST", _wrap_delete_Dwg_Object_FIELDLIST, METH_O, NULL},
	 { "Dwg_Object_FIELDLIST_swigregister", Dwg_Object_FIELDLIST_swigregister, METH_O, NULL},
	 { "Dwg_Object_FIELDLIST_swiginit", Dwg_Object_FIELDLIST_swiginit, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshpt_source_pt_set", _wrap_Dwg_GEODATA_meshpt_source_pt_set, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshpt_source_pt_get", _wrap_Dwg_GEODATA_meshpt_source_pt_get, METH_O, NULL},
	 { "Dwg_GEODATA_meshpt_dest_pt_set", _wrap_Dwg_GEODATA_meshpt_dest_pt_set, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshpt_dest_pt_get", _wrap_Dwg_GEODATA_meshpt_dest_pt_get, METH_O, NULL},
	 { "new_Dwg_GEODATA_meshpt", _wrap_new_Dwg_GEODATA_meshpt, METH_NOARGS, NULL},
	 { "delete_Dwg_GEODATA_meshpt", _wrap_delete_Dwg_GEODATA_meshpt, METH_O, NULL},
	 { "Dwg_GEODATA_meshpt_swigregister", Dwg_GEODATA_meshpt_swigregister, METH_O, NULL},
	 { "Dwg_GEODATA_meshpt_swiginit", Dwg_GEODATA_meshpt_swiginit, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshface_face1_set", _wrap_Dwg_GEODATA_meshface_face1_set, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshface_face1_get", _wrap_Dwg_GEODATA_meshface_face1_get, METH_O, NULL},
	 { "Dwg_GEODATA_meshface_face2_set", _wrap_Dwg_GEODATA_meshface_face2_set, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshface_face2_get", _wrap_Dwg_GEODATA_meshface_face2_get, METH_O, NULL},
	 { "Dwg_GEODATA_meshface_face3_set", _wrap_Dwg_GEODATA_meshface_face3_set, METH_VARARGS, NULL},
	 { "Dwg_GEODATA_meshface_face3_get", _wrap_Dwg_GEODATA_meshface_face3_get, METH_O, NULL},
	 { "new_Dwg_GEODATA_meshface", _wrap_new_Dwg_GEODATA_meshface, METH_NOARGS, NULL},
	 { "delete_Dwg_GEODATA_meshface", _wrap_delete_Dwg_GEODATA_meshface, METH_O, NULL},
	 { "Dwg_GEODATA_meshface_swigregister", Dwg_GEODATA_meshface_swigregister, METH_O, NULL},
	 { "Dwg_GEODATA_meshface_swiginit", Dwg_GEODATA_meshface_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_parent_set", _wrap_Dwg_Object_GEODATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_parent_get", _wrap_Dwg_Object_GEODATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_class_version_set", _wrap_Dwg_Object_GEODATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_class_version_get", _wrap_Dwg_Object_GEODATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_host_block_set", _wrap_Dwg_Object_GEODATA_host_block_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_host_block_get", _wrap_Dwg_Object_GEODATA_host_block_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_coord_type_set", _wrap_Dwg_Object_GEODATA_coord_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_coord_type_get", _wrap_Dwg_Object_GEODATA_coord_type_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_design_pt_set", _wrap_Dwg_Object_GEODATA_design_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_design_pt_get", _wrap_Dwg_Object_GEODATA_design_pt_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_ref_pt_set", _wrap_Dwg_Object_GEODATA_ref_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_ref_pt_get", _wrap_Dwg_Object_GEODATA_ref_pt_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_obs_pt_set", _wrap_Dwg_Object_GEODATA_obs_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_obs_pt_get", _wrap_Dwg_Object_GEODATA_obs_pt_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_scale_vec_set", _wrap_Dwg_Object_GEODATA_scale_vec_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_scale_vec_get", _wrap_Dwg_Object_GEODATA_scale_vec_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_unit_scale_horiz_set", _wrap_Dwg_Object_GEODATA_unit_scale_horiz_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_unit_scale_horiz_get", _wrap_Dwg_Object_GEODATA_unit_scale_horiz_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_units_value_horiz_set", _wrap_Dwg_Object_GEODATA_units_value_horiz_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_units_value_horiz_get", _wrap_Dwg_Object_GEODATA_units_value_horiz_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_unit_scale_vert_set", _wrap_Dwg_Object_GEODATA_unit_scale_vert_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_unit_scale_vert_get", _wrap_Dwg_Object_GEODATA_unit_scale_vert_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_units_value_vert_set", _wrap_Dwg_Object_GEODATA_units_value_vert_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_units_value_vert_get", _wrap_Dwg_Object_GEODATA_units_value_vert_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_up_dir_set", _wrap_Dwg_Object_GEODATA_up_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_up_dir_get", _wrap_Dwg_Object_GEODATA_up_dir_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_north_dir_set", _wrap_Dwg_Object_GEODATA_north_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_north_dir_get", _wrap_Dwg_Object_GEODATA_north_dir_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_scale_est_set", _wrap_Dwg_Object_GEODATA_scale_est_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_scale_est_get", _wrap_Dwg_Object_GEODATA_scale_est_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_user_scale_factor_set", _wrap_Dwg_Object_GEODATA_user_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_user_scale_factor_get", _wrap_Dwg_Object_GEODATA_user_scale_factor_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_do_sea_level_corr_set", _wrap_Dwg_Object_GEODATA_do_sea_level_corr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_do_sea_level_corr_get", _wrap_Dwg_Object_GEODATA_do_sea_level_corr_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_sea_level_elev_set", _wrap_Dwg_Object_GEODATA_sea_level_elev_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_sea_level_elev_get", _wrap_Dwg_Object_GEODATA_sea_level_elev_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_coord_proj_radius_set", _wrap_Dwg_Object_GEODATA_coord_proj_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_coord_proj_radius_get", _wrap_Dwg_Object_GEODATA_coord_proj_radius_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_coord_system_def_set", _wrap_Dwg_Object_GEODATA_coord_system_def_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_coord_system_def_get", _wrap_Dwg_Object_GEODATA_coord_system_def_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_geo_rss_tag_set", _wrap_Dwg_Object_GEODATA_geo_rss_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_geo_rss_tag_get", _wrap_Dwg_Object_GEODATA_geo_rss_tag_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_coord_system_datum_set", _wrap_Dwg_Object_GEODATA_coord_system_datum_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_coord_system_datum_get", _wrap_Dwg_Object_GEODATA_coord_system_datum_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_coord_system_wkt_set", _wrap_Dwg_Object_GEODATA_coord_system_wkt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_coord_system_wkt_get", _wrap_Dwg_Object_GEODATA_coord_system_wkt_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_observation_from_tag_set", _wrap_Dwg_Object_GEODATA_observation_from_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_observation_from_tag_get", _wrap_Dwg_Object_GEODATA_observation_from_tag_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_observation_to_tag_set", _wrap_Dwg_Object_GEODATA_observation_to_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_observation_to_tag_get", _wrap_Dwg_Object_GEODATA_observation_to_tag_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_observation_coverage_tag_set", _wrap_Dwg_Object_GEODATA_observation_coverage_tag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_observation_coverage_tag_get", _wrap_Dwg_Object_GEODATA_observation_coverage_tag_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_num_geomesh_pts_set", _wrap_Dwg_Object_GEODATA_num_geomesh_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_num_geomesh_pts_get", _wrap_Dwg_Object_GEODATA_num_geomesh_pts_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_geomesh_pts_set", _wrap_Dwg_Object_GEODATA_geomesh_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_geomesh_pts_get", _wrap_Dwg_Object_GEODATA_geomesh_pts_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_num_geomesh_faces_set", _wrap_Dwg_Object_GEODATA_num_geomesh_faces_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_num_geomesh_faces_get", _wrap_Dwg_Object_GEODATA_num_geomesh_faces_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_geomesh_faces_set", _wrap_Dwg_Object_GEODATA_geomesh_faces_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_geomesh_faces_get", _wrap_Dwg_Object_GEODATA_geomesh_faces_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_has_civil_data_set", _wrap_Dwg_Object_GEODATA_has_civil_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_has_civil_data_get", _wrap_Dwg_Object_GEODATA_has_civil_data_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_obsolete_false_set", _wrap_Dwg_Object_GEODATA_obsolete_false_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_obsolete_false_get", _wrap_Dwg_Object_GEODATA_obsolete_false_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_ref_pt2d_set", _wrap_Dwg_Object_GEODATA_ref_pt2d_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_ref_pt2d_get", _wrap_Dwg_Object_GEODATA_ref_pt2d_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_zero1_set", _wrap_Dwg_Object_GEODATA_zero1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_zero1_get", _wrap_Dwg_Object_GEODATA_zero1_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_zero2_set", _wrap_Dwg_Object_GEODATA_zero2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_zero2_get", _wrap_Dwg_Object_GEODATA_zero2_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_unknown1_set", _wrap_Dwg_Object_GEODATA_unknown1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_unknown1_get", _wrap_Dwg_Object_GEODATA_unknown1_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_unknown2_set", _wrap_Dwg_Object_GEODATA_unknown2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_unknown2_get", _wrap_Dwg_Object_GEODATA_unknown2_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_unknown_b_set", _wrap_Dwg_Object_GEODATA_unknown_b_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_unknown_b_get", _wrap_Dwg_Object_GEODATA_unknown_b_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_north_dir_angle_deg_set", _wrap_Dwg_Object_GEODATA_north_dir_angle_deg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_north_dir_angle_deg_get", _wrap_Dwg_Object_GEODATA_north_dir_angle_deg_get, METH_O, NULL},
	 { "Dwg_Object_GEODATA_north_dir_angle_rad_set", _wrap_Dwg_Object_GEODATA_north_dir_angle_rad_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEODATA_north_dir_angle_rad_get", _wrap_Dwg_Object_GEODATA_north_dir_angle_rad_get, METH_O, NULL},
	 { "new_Dwg_Object_GEODATA", _wrap_new_Dwg_Object_GEODATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_GEODATA", _wrap_delete_Dwg_Object_GEODATA, METH_O, NULL},
	 { "Dwg_Object_GEODATA_swigregister", Dwg_Object_GEODATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_GEODATA_swiginit", Dwg_Object_GEODATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_IDBUFFER_parent_set", _wrap_Dwg_Object_IDBUFFER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IDBUFFER_parent_get", _wrap_Dwg_Object_IDBUFFER_parent_get, METH_O, NULL},
	 { "Dwg_Object_IDBUFFER_unknown_set", _wrap_Dwg_Object_IDBUFFER_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IDBUFFER_unknown_get", _wrap_Dwg_Object_IDBUFFER_unknown_get, METH_O, NULL},
	 { "Dwg_Object_IDBUFFER_num_obj_ids_set", _wrap_Dwg_Object_IDBUFFER_num_obj_ids_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IDBUFFER_num_obj_ids_get", _wrap_Dwg_Object_IDBUFFER_num_obj_ids_get, METH_O, NULL},
	 { "Dwg_Object_IDBUFFER_obj_ids_set", _wrap_Dwg_Object_IDBUFFER_obj_ids_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IDBUFFER_obj_ids_get", _wrap_Dwg_Object_IDBUFFER_obj_ids_get, METH_O, NULL},
	 { "new_Dwg_Object_IDBUFFER", _wrap_new_Dwg_Object_IDBUFFER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_IDBUFFER", _wrap_delete_Dwg_Object_IDBUFFER, METH_O, NULL},
	 { "Dwg_Object_IDBUFFER_swigregister", Dwg_Object_IDBUFFER_swigregister, METH_O, NULL},
	 { "Dwg_Object_IDBUFFER_swiginit", Dwg_Object_IDBUFFER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_parent_set", _wrap_Dwg_Entity_IMAGE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_parent_get", _wrap_Dwg_Entity_IMAGE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_class_version_set", _wrap_Dwg_Entity_IMAGE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_class_version_get", _wrap_Dwg_Entity_IMAGE_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_pt0_set", _wrap_Dwg_Entity_IMAGE_pt0_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_pt0_get", _wrap_Dwg_Entity_IMAGE_pt0_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_uvec_set", _wrap_Dwg_Entity_IMAGE_uvec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_uvec_get", _wrap_Dwg_Entity_IMAGE_uvec_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_vvec_set", _wrap_Dwg_Entity_IMAGE_vvec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_vvec_get", _wrap_Dwg_Entity_IMAGE_vvec_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_image_size_set", _wrap_Dwg_Entity_IMAGE_image_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_image_size_get", _wrap_Dwg_Entity_IMAGE_image_size_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_display_props_set", _wrap_Dwg_Entity_IMAGE_display_props_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_display_props_get", _wrap_Dwg_Entity_IMAGE_display_props_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_clipping_set", _wrap_Dwg_Entity_IMAGE_clipping_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_clipping_get", _wrap_Dwg_Entity_IMAGE_clipping_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_brightness_set", _wrap_Dwg_Entity_IMAGE_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_brightness_get", _wrap_Dwg_Entity_IMAGE_brightness_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_contrast_set", _wrap_Dwg_Entity_IMAGE_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_contrast_get", _wrap_Dwg_Entity_IMAGE_contrast_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_fade_set", _wrap_Dwg_Entity_IMAGE_fade_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_fade_get", _wrap_Dwg_Entity_IMAGE_fade_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_clip_mode_set", _wrap_Dwg_Entity_IMAGE_clip_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_clip_mode_get", _wrap_Dwg_Entity_IMAGE_clip_mode_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_clip_boundary_type_set", _wrap_Dwg_Entity_IMAGE_clip_boundary_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_clip_boundary_type_get", _wrap_Dwg_Entity_IMAGE_clip_boundary_type_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_num_clip_verts_set", _wrap_Dwg_Entity_IMAGE_num_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_num_clip_verts_get", _wrap_Dwg_Entity_IMAGE_num_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_clip_verts_set", _wrap_Dwg_Entity_IMAGE_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_clip_verts_get", _wrap_Dwg_Entity_IMAGE_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_imagedef_set", _wrap_Dwg_Entity_IMAGE_imagedef_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_imagedef_get", _wrap_Dwg_Entity_IMAGE_imagedef_get, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_imagedefreactor_set", _wrap_Dwg_Entity_IMAGE_imagedefreactor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_IMAGE_imagedefreactor_get", _wrap_Dwg_Entity_IMAGE_imagedefreactor_get, METH_O, NULL},
	 { "new_Dwg_Entity_IMAGE", _wrap_new_Dwg_Entity_IMAGE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_IMAGE", _wrap_delete_Dwg_Entity_IMAGE, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_swigregister", Dwg_Entity_IMAGE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_IMAGE_swiginit", Dwg_Entity_IMAGE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_parent_set", _wrap_Dwg_Object_IMAGEDEF_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_parent_get", _wrap_Dwg_Object_IMAGEDEF_parent_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_class_version_set", _wrap_Dwg_Object_IMAGEDEF_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_class_version_get", _wrap_Dwg_Object_IMAGEDEF_class_version_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_image_size_set", _wrap_Dwg_Object_IMAGEDEF_image_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_image_size_get", _wrap_Dwg_Object_IMAGEDEF_image_size_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_file_path_set", _wrap_Dwg_Object_IMAGEDEF_file_path_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_file_path_get", _wrap_Dwg_Object_IMAGEDEF_file_path_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_is_loaded_set", _wrap_Dwg_Object_IMAGEDEF_is_loaded_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_is_loaded_get", _wrap_Dwg_Object_IMAGEDEF_is_loaded_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_resunits_set", _wrap_Dwg_Object_IMAGEDEF_resunits_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_resunits_get", _wrap_Dwg_Object_IMAGEDEF_resunits_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_pixel_size_set", _wrap_Dwg_Object_IMAGEDEF_pixel_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_pixel_size_get", _wrap_Dwg_Object_IMAGEDEF_pixel_size_get, METH_O, NULL},
	 { "new_Dwg_Object_IMAGEDEF", _wrap_new_Dwg_Object_IMAGEDEF, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_IMAGEDEF", _wrap_delete_Dwg_Object_IMAGEDEF, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_swigregister", Dwg_Object_IMAGEDEF_swigregister, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_swiginit", Dwg_Object_IMAGEDEF_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_parent_set", _wrap_Dwg_Object_IMAGEDEF_REACTOR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_parent_get", _wrap_Dwg_Object_IMAGEDEF_REACTOR_parent_get, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_class_version_set", _wrap_Dwg_Object_IMAGEDEF_REACTOR_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_class_version_get", _wrap_Dwg_Object_IMAGEDEF_REACTOR_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_IMAGEDEF_REACTOR", _wrap_new_Dwg_Object_IMAGEDEF_REACTOR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_IMAGEDEF_REACTOR", _wrap_delete_Dwg_Object_IMAGEDEF_REACTOR, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_swigregister", Dwg_Object_IMAGEDEF_REACTOR_swigregister, METH_O, NULL},
	 { "Dwg_Object_IMAGEDEF_REACTOR_swiginit", Dwg_Object_IMAGEDEF_REACTOR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_INDEX_parent_set", _wrap_Dwg_Object_INDEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_INDEX_parent_get", _wrap_Dwg_Object_INDEX_parent_get, METH_O, NULL},
	 { "Dwg_Object_INDEX_last_updated_set", _wrap_Dwg_Object_INDEX_last_updated_set, METH_VARARGS, NULL},
	 { "Dwg_Object_INDEX_last_updated_get", _wrap_Dwg_Object_INDEX_last_updated_get, METH_O, NULL},
	 { "new_Dwg_Object_INDEX", _wrap_new_Dwg_Object_INDEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_INDEX", _wrap_delete_Dwg_Object_INDEX, METH_O, NULL},
	 { "Dwg_Object_INDEX_swigregister", Dwg_Object_INDEX_swigregister, METH_O, NULL},
	 { "Dwg_Object_INDEX_swiginit", Dwg_Object_INDEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LAYER_entry_parent_set", _wrap_Dwg_LAYER_entry_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LAYER_entry_parent_get", _wrap_Dwg_LAYER_entry_parent_get, METH_O, NULL},
	 { "Dwg_LAYER_entry_numlayers_set", _wrap_Dwg_LAYER_entry_numlayers_set, METH_VARARGS, NULL},
	 { "Dwg_LAYER_entry_numlayers_get", _wrap_Dwg_LAYER_entry_numlayers_get, METH_O, NULL},
	 { "Dwg_LAYER_entry_name_set", _wrap_Dwg_LAYER_entry_name_set, METH_VARARGS, NULL},
	 { "Dwg_LAYER_entry_name_get", _wrap_Dwg_LAYER_entry_name_get, METH_O, NULL},
	 { "Dwg_LAYER_entry_handle_set", _wrap_Dwg_LAYER_entry_handle_set, METH_VARARGS, NULL},
	 { "Dwg_LAYER_entry_handle_get", _wrap_Dwg_LAYER_entry_handle_get, METH_O, NULL},
	 { "new_Dwg_LAYER_entry", _wrap_new_Dwg_LAYER_entry, METH_NOARGS, NULL},
	 { "delete_Dwg_LAYER_entry", _wrap_delete_Dwg_LAYER_entry, METH_O, NULL},
	 { "Dwg_LAYER_entry_swigregister", Dwg_LAYER_entry_swigregister, METH_O, NULL},
	 { "Dwg_LAYER_entry_swiginit", Dwg_LAYER_entry_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_INDEX_parent_set", _wrap_Dwg_Object_LAYER_INDEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_INDEX_parent_get", _wrap_Dwg_Object_LAYER_INDEX_parent_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_INDEX_last_updated_set", _wrap_Dwg_Object_LAYER_INDEX_last_updated_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_INDEX_last_updated_get", _wrap_Dwg_Object_LAYER_INDEX_last_updated_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_INDEX_num_entries_set", _wrap_Dwg_Object_LAYER_INDEX_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_INDEX_num_entries_get", _wrap_Dwg_Object_LAYER_INDEX_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_LAYER_INDEX_entries_set", _wrap_Dwg_Object_LAYER_INDEX_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYER_INDEX_entries_get", _wrap_Dwg_Object_LAYER_INDEX_entries_get, METH_O, NULL},
	 { "new_Dwg_Object_LAYER_INDEX", _wrap_new_Dwg_Object_LAYER_INDEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LAYER_INDEX", _wrap_delete_Dwg_Object_LAYER_INDEX, METH_O, NULL},
	 { "Dwg_Object_LAYER_INDEX_swigregister", Dwg_Object_LAYER_INDEX_swigregister, METH_O, NULL},
	 { "Dwg_Object_LAYER_INDEX_swiginit", Dwg_Object_LAYER_INDEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_parent_set", _wrap_Dwg_Entity_LWPOLYLINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_parent_get", _wrap_Dwg_Entity_LWPOLYLINE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_flag_set", _wrap_Dwg_Entity_LWPOLYLINE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_flag_get", _wrap_Dwg_Entity_LWPOLYLINE_flag_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_const_width_set", _wrap_Dwg_Entity_LWPOLYLINE_const_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_const_width_get", _wrap_Dwg_Entity_LWPOLYLINE_const_width_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_elevation_set", _wrap_Dwg_Entity_LWPOLYLINE_elevation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_elevation_get", _wrap_Dwg_Entity_LWPOLYLINE_elevation_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_thickness_set", _wrap_Dwg_Entity_LWPOLYLINE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_thickness_get", _wrap_Dwg_Entity_LWPOLYLINE_thickness_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_extrusion_set", _wrap_Dwg_Entity_LWPOLYLINE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_extrusion_get", _wrap_Dwg_Entity_LWPOLYLINE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_points_set", _wrap_Dwg_Entity_LWPOLYLINE_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_points_get", _wrap_Dwg_Entity_LWPOLYLINE_num_points_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_points_set", _wrap_Dwg_Entity_LWPOLYLINE_points_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_points_get", _wrap_Dwg_Entity_LWPOLYLINE_points_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_bulges_set", _wrap_Dwg_Entity_LWPOLYLINE_num_bulges_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_bulges_get", _wrap_Dwg_Entity_LWPOLYLINE_num_bulges_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_bulges_set", _wrap_Dwg_Entity_LWPOLYLINE_bulges_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_bulges_get", _wrap_Dwg_Entity_LWPOLYLINE_bulges_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_vertexids_set", _wrap_Dwg_Entity_LWPOLYLINE_num_vertexids_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_vertexids_get", _wrap_Dwg_Entity_LWPOLYLINE_num_vertexids_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_vertexids_set", _wrap_Dwg_Entity_LWPOLYLINE_vertexids_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_vertexids_get", _wrap_Dwg_Entity_LWPOLYLINE_vertexids_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_widths_set", _wrap_Dwg_Entity_LWPOLYLINE_num_widths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_num_widths_get", _wrap_Dwg_Entity_LWPOLYLINE_num_widths_get, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_widths_set", _wrap_Dwg_Entity_LWPOLYLINE_widths_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LWPOLYLINE_widths_get", _wrap_Dwg_Entity_LWPOLYLINE_widths_get, METH_O, NULL},
	 { "new_Dwg_Entity_LWPOLYLINE", _wrap_new_Dwg_Entity_LWPOLYLINE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LWPOLYLINE", _wrap_delete_Dwg_Entity_LWPOLYLINE, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_swigregister", Dwg_Entity_LWPOLYLINE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LWPOLYLINE_swiginit", Dwg_Entity_LWPOLYLINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_parent_set", _wrap_Dwg_Object_RASTERVARIABLES_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_parent_get", _wrap_Dwg_Object_RASTERVARIABLES_parent_get, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_class_version_set", _wrap_Dwg_Object_RASTERVARIABLES_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_class_version_get", _wrap_Dwg_Object_RASTERVARIABLES_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_image_frame_set", _wrap_Dwg_Object_RASTERVARIABLES_image_frame_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_image_frame_get", _wrap_Dwg_Object_RASTERVARIABLES_image_frame_get, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_image_quality_set", _wrap_Dwg_Object_RASTERVARIABLES_image_quality_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_image_quality_get", _wrap_Dwg_Object_RASTERVARIABLES_image_quality_get, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_units_set", _wrap_Dwg_Object_RASTERVARIABLES_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RASTERVARIABLES_units_get", _wrap_Dwg_Object_RASTERVARIABLES_units_get, METH_O, NULL},
	 { "new_Dwg_Object_RASTERVARIABLES", _wrap_new_Dwg_Object_RASTERVARIABLES, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RASTERVARIABLES", _wrap_delete_Dwg_Object_RASTERVARIABLES, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_swigregister", Dwg_Object_RASTERVARIABLES_swigregister, METH_O, NULL},
	 { "Dwg_Object_RASTERVARIABLES_swiginit", Dwg_Object_RASTERVARIABLES_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_parent_set", _wrap_Dwg_Object_SCALE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_parent_get", _wrap_Dwg_Object_SCALE_parent_get, METH_O, NULL},
	 { "Dwg_Object_SCALE_flag_set", _wrap_Dwg_Object_SCALE_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_flag_get", _wrap_Dwg_Object_SCALE_flag_get, METH_O, NULL},
	 { "Dwg_Object_SCALE_name_set", _wrap_Dwg_Object_SCALE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_name_get", _wrap_Dwg_Object_SCALE_name_get, METH_O, NULL},
	 { "Dwg_Object_SCALE_paper_units_set", _wrap_Dwg_Object_SCALE_paper_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_paper_units_get", _wrap_Dwg_Object_SCALE_paper_units_get, METH_O, NULL},
	 { "Dwg_Object_SCALE_drawing_units_set", _wrap_Dwg_Object_SCALE_drawing_units_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_drawing_units_get", _wrap_Dwg_Object_SCALE_drawing_units_get, METH_O, NULL},
	 { "Dwg_Object_SCALE_is_unit_scale_set", _wrap_Dwg_Object_SCALE_is_unit_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SCALE_is_unit_scale_get", _wrap_Dwg_Object_SCALE_is_unit_scale_get, METH_O, NULL},
	 { "new_Dwg_Object_SCALE", _wrap_new_Dwg_Object_SCALE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SCALE", _wrap_delete_Dwg_Object_SCALE, METH_O, NULL},
	 { "Dwg_Object_SCALE_swigregister", Dwg_Object_SCALE_swigregister, METH_O, NULL},
	 { "Dwg_Object_SCALE_swiginit", Dwg_Object_SCALE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_parent_set", _wrap_Dwg_Object_SORTENTSTABLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_parent_get", _wrap_Dwg_Object_SORTENTSTABLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_num_ents_set", _wrap_Dwg_Object_SORTENTSTABLE_num_ents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_num_ents_get", _wrap_Dwg_Object_SORTENTSTABLE_num_ents_get, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_sort_ents_set", _wrap_Dwg_Object_SORTENTSTABLE_sort_ents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_sort_ents_get", _wrap_Dwg_Object_SORTENTSTABLE_sort_ents_get, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_block_owner_set", _wrap_Dwg_Object_SORTENTSTABLE_block_owner_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_block_owner_get", _wrap_Dwg_Object_SORTENTSTABLE_block_owner_get, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_ents_set", _wrap_Dwg_Object_SORTENTSTABLE_ents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SORTENTSTABLE_ents_get", _wrap_Dwg_Object_SORTENTSTABLE_ents_get, METH_O, NULL},
	 { "new_Dwg_Object_SORTENTSTABLE", _wrap_new_Dwg_Object_SORTENTSTABLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SORTENTSTABLE", _wrap_delete_Dwg_Object_SORTENTSTABLE, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_swigregister", Dwg_Object_SORTENTSTABLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_SORTENTSTABLE_swiginit", Dwg_Object_SORTENTSTABLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_parent_set", _wrap_Dwg_Object_SPATIAL_FILTER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_parent_get", _wrap_Dwg_Object_SPATIAL_FILTER_parent_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_num_clip_verts_set", _wrap_Dwg_Object_SPATIAL_FILTER_num_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_num_clip_verts_get", _wrap_Dwg_Object_SPATIAL_FILTER_num_clip_verts_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_clip_verts_set", _wrap_Dwg_Object_SPATIAL_FILTER_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_clip_verts_get", _wrap_Dwg_Object_SPATIAL_FILTER_clip_verts_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_extrusion_set", _wrap_Dwg_Object_SPATIAL_FILTER_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_extrusion_get", _wrap_Dwg_Object_SPATIAL_FILTER_extrusion_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_origin_set", _wrap_Dwg_Object_SPATIAL_FILTER_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_origin_get", _wrap_Dwg_Object_SPATIAL_FILTER_origin_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_display_boundary_on_set", _wrap_Dwg_Object_SPATIAL_FILTER_display_boundary_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_display_boundary_on_get", _wrap_Dwg_Object_SPATIAL_FILTER_display_boundary_on_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_front_clip_on_set", _wrap_Dwg_Object_SPATIAL_FILTER_front_clip_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_front_clip_on_get", _wrap_Dwg_Object_SPATIAL_FILTER_front_clip_on_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_front_clip_z_set", _wrap_Dwg_Object_SPATIAL_FILTER_front_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_front_clip_z_get", _wrap_Dwg_Object_SPATIAL_FILTER_front_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_back_clip_on_set", _wrap_Dwg_Object_SPATIAL_FILTER_back_clip_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_back_clip_on_get", _wrap_Dwg_Object_SPATIAL_FILTER_back_clip_on_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_back_clip_z_set", _wrap_Dwg_Object_SPATIAL_FILTER_back_clip_z_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_back_clip_z_get", _wrap_Dwg_Object_SPATIAL_FILTER_back_clip_z_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_inverse_transform_set", _wrap_Dwg_Object_SPATIAL_FILTER_inverse_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_inverse_transform_get", _wrap_Dwg_Object_SPATIAL_FILTER_inverse_transform_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_transform_set", _wrap_Dwg_Object_SPATIAL_FILTER_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_transform_get", _wrap_Dwg_Object_SPATIAL_FILTER_transform_get, METH_O, NULL},
	 { "new_Dwg_Object_SPATIAL_FILTER", _wrap_new_Dwg_Object_SPATIAL_FILTER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SPATIAL_FILTER", _wrap_delete_Dwg_Object_SPATIAL_FILTER, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_swigregister", Dwg_Object_SPATIAL_FILTER_swigregister, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_FILTER_swiginit", Dwg_Object_SPATIAL_FILTER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_parent_set", _wrap_Dwg_Object_SPATIAL_INDEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_parent_get", _wrap_Dwg_Object_SPATIAL_INDEX_parent_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_last_updated_set", _wrap_Dwg_Object_SPATIAL_INDEX_last_updated_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_last_updated_get", _wrap_Dwg_Object_SPATIAL_INDEX_last_updated_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num1_set", _wrap_Dwg_Object_SPATIAL_INDEX_num1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num1_get", _wrap_Dwg_Object_SPATIAL_INDEX_num1_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num2_set", _wrap_Dwg_Object_SPATIAL_INDEX_num2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num2_get", _wrap_Dwg_Object_SPATIAL_INDEX_num2_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num3_set", _wrap_Dwg_Object_SPATIAL_INDEX_num3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num3_get", _wrap_Dwg_Object_SPATIAL_INDEX_num3_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num4_set", _wrap_Dwg_Object_SPATIAL_INDEX_num4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num4_get", _wrap_Dwg_Object_SPATIAL_INDEX_num4_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num5_set", _wrap_Dwg_Object_SPATIAL_INDEX_num5_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num5_get", _wrap_Dwg_Object_SPATIAL_INDEX_num5_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num6_set", _wrap_Dwg_Object_SPATIAL_INDEX_num6_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num6_get", _wrap_Dwg_Object_SPATIAL_INDEX_num6_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num_hdls_set", _wrap_Dwg_Object_SPATIAL_INDEX_num_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_num_hdls_get", _wrap_Dwg_Object_SPATIAL_INDEX_num_hdls_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_hdls_set", _wrap_Dwg_Object_SPATIAL_INDEX_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_hdls_get", _wrap_Dwg_Object_SPATIAL_INDEX_hdls_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_bindata_size_set", _wrap_Dwg_Object_SPATIAL_INDEX_bindata_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_bindata_size_get", _wrap_Dwg_Object_SPATIAL_INDEX_bindata_size_get, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_bindata_set", _wrap_Dwg_Object_SPATIAL_INDEX_bindata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_bindata_get", _wrap_Dwg_Object_SPATIAL_INDEX_bindata_get, METH_O, NULL},
	 { "new_Dwg_Object_SPATIAL_INDEX", _wrap_new_Dwg_Object_SPATIAL_INDEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SPATIAL_INDEX", _wrap_delete_Dwg_Object_SPATIAL_INDEX, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_swigregister", Dwg_Object_SPATIAL_INDEX_swigregister, METH_O, NULL},
	 { "Dwg_Object_SPATIAL_INDEX_swiginit", Dwg_Object_SPATIAL_INDEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_parent_set", _wrap_Dwg_Entity_WIPEOUT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_parent_get", _wrap_Dwg_Entity_WIPEOUT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_class_version_set", _wrap_Dwg_Entity_WIPEOUT_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_class_version_get", _wrap_Dwg_Entity_WIPEOUT_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_pt0_set", _wrap_Dwg_Entity_WIPEOUT_pt0_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_pt0_get", _wrap_Dwg_Entity_WIPEOUT_pt0_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_uvec_set", _wrap_Dwg_Entity_WIPEOUT_uvec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_uvec_get", _wrap_Dwg_Entity_WIPEOUT_uvec_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_vvec_set", _wrap_Dwg_Entity_WIPEOUT_vvec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_vvec_get", _wrap_Dwg_Entity_WIPEOUT_vvec_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_image_size_set", _wrap_Dwg_Entity_WIPEOUT_image_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_image_size_get", _wrap_Dwg_Entity_WIPEOUT_image_size_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_display_props_set", _wrap_Dwg_Entity_WIPEOUT_display_props_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_display_props_get", _wrap_Dwg_Entity_WIPEOUT_display_props_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_clipping_set", _wrap_Dwg_Entity_WIPEOUT_clipping_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_clipping_get", _wrap_Dwg_Entity_WIPEOUT_clipping_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_brightness_set", _wrap_Dwg_Entity_WIPEOUT_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_brightness_get", _wrap_Dwg_Entity_WIPEOUT_brightness_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_contrast_set", _wrap_Dwg_Entity_WIPEOUT_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_contrast_get", _wrap_Dwg_Entity_WIPEOUT_contrast_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_fade_set", _wrap_Dwg_Entity_WIPEOUT_fade_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_fade_get", _wrap_Dwg_Entity_WIPEOUT_fade_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_mode_set", _wrap_Dwg_Entity_WIPEOUT_clip_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_mode_get", _wrap_Dwg_Entity_WIPEOUT_clip_mode_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_boundary_type_set", _wrap_Dwg_Entity_WIPEOUT_clip_boundary_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_boundary_type_get", _wrap_Dwg_Entity_WIPEOUT_clip_boundary_type_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_num_clip_verts_set", _wrap_Dwg_Entity_WIPEOUT_num_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_num_clip_verts_get", _wrap_Dwg_Entity_WIPEOUT_num_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_verts_set", _wrap_Dwg_Entity_WIPEOUT_clip_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_clip_verts_get", _wrap_Dwg_Entity_WIPEOUT_clip_verts_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_imagedef_set", _wrap_Dwg_Entity_WIPEOUT_imagedef_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_imagedef_get", _wrap_Dwg_Entity_WIPEOUT_imagedef_get, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_imagedefreactor_set", _wrap_Dwg_Entity_WIPEOUT_imagedefreactor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_WIPEOUT_imagedefreactor_get", _wrap_Dwg_Entity_WIPEOUT_imagedefreactor_get, METH_O, NULL},
	 { "new_Dwg_Entity_WIPEOUT", _wrap_new_Dwg_Entity_WIPEOUT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_WIPEOUT", _wrap_delete_Dwg_Entity_WIPEOUT, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_swigregister", Dwg_Entity_WIPEOUT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_WIPEOUT_swiginit", Dwg_Entity_WIPEOUT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_parent_set", _wrap_Dwg_Object_WIPEOUTVARIABLES_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_parent_get", _wrap_Dwg_Object_WIPEOUTVARIABLES_parent_get, METH_O, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_display_frame_set", _wrap_Dwg_Object_WIPEOUTVARIABLES_display_frame_set, METH_VARARGS, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_display_frame_get", _wrap_Dwg_Object_WIPEOUTVARIABLES_display_frame_get, METH_O, NULL},
	 { "new_Dwg_Object_WIPEOUTVARIABLES", _wrap_new_Dwg_Object_WIPEOUTVARIABLES, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_WIPEOUTVARIABLES", _wrap_delete_Dwg_Object_WIPEOUTVARIABLES, METH_O, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_swigregister", Dwg_Object_WIPEOUTVARIABLES_swigregister, METH_O, NULL},
	 { "Dwg_Object_WIPEOUTVARIABLES_swiginit", Dwg_Object_WIPEOUTVARIABLES_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_parent_set", _wrap_Dwg_Entity_SECTIONOBJECT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_parent_get", _wrap_Dwg_Entity_SECTIONOBJECT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_state_set", _wrap_Dwg_Entity_SECTIONOBJECT_state_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_state_get", _wrap_Dwg_Entity_SECTIONOBJECT_state_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_flags_set", _wrap_Dwg_Entity_SECTIONOBJECT_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_flags_get", _wrap_Dwg_Entity_SECTIONOBJECT_flags_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_name_set", _wrap_Dwg_Entity_SECTIONOBJECT_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_name_get", _wrap_Dwg_Entity_SECTIONOBJECT_name_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_vert_dir_set", _wrap_Dwg_Entity_SECTIONOBJECT_vert_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_vert_dir_get", _wrap_Dwg_Entity_SECTIONOBJECT_vert_dir_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_top_height_set", _wrap_Dwg_Entity_SECTIONOBJECT_top_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_top_height_get", _wrap_Dwg_Entity_SECTIONOBJECT_top_height_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_bottom_height_set", _wrap_Dwg_Entity_SECTIONOBJECT_bottom_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_bottom_height_get", _wrap_Dwg_Entity_SECTIONOBJECT_bottom_height_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_indicator_alpha_set", _wrap_Dwg_Entity_SECTIONOBJECT_indicator_alpha_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_indicator_alpha_get", _wrap_Dwg_Entity_SECTIONOBJECT_indicator_alpha_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_indicator_color_set", _wrap_Dwg_Entity_SECTIONOBJECT_indicator_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_indicator_color_get", _wrap_Dwg_Entity_SECTIONOBJECT_indicator_color_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_num_verts_set", _wrap_Dwg_Entity_SECTIONOBJECT_num_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_num_verts_get", _wrap_Dwg_Entity_SECTIONOBJECT_num_verts_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_verts_set", _wrap_Dwg_Entity_SECTIONOBJECT_verts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_verts_get", _wrap_Dwg_Entity_SECTIONOBJECT_verts_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_num_blverts_set", _wrap_Dwg_Entity_SECTIONOBJECT_num_blverts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_num_blverts_get", _wrap_Dwg_Entity_SECTIONOBJECT_num_blverts_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_blverts_set", _wrap_Dwg_Entity_SECTIONOBJECT_blverts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_blverts_get", _wrap_Dwg_Entity_SECTIONOBJECT_blverts_get, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_section_settings_set", _wrap_Dwg_Entity_SECTIONOBJECT_section_settings_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_section_settings_get", _wrap_Dwg_Entity_SECTIONOBJECT_section_settings_get, METH_O, NULL},
	 { "new_Dwg_Entity_SECTIONOBJECT", _wrap_new_Dwg_Entity_SECTIONOBJECT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SECTIONOBJECT", _wrap_delete_Dwg_Entity_SECTIONOBJECT, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_swigregister", Dwg_Entity_SECTIONOBJECT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SECTIONOBJECT_swiginit", Dwg_Entity_SECTIONOBJECT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_parent_set", _wrap_Dwg_Object_VISUALSTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_parent_get", _wrap_Dwg_Object_VISUALSTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_description_set", _wrap_Dwg_Object_VISUALSTYLE_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_description_get", _wrap_Dwg_Object_VISUALSTYLE_description_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_style_type_set", _wrap_Dwg_Object_VISUALSTYLE_style_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_style_type_get", _wrap_Dwg_Object_VISUALSTYLE_style_type_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_ext_lighting_model_set", _wrap_Dwg_Object_VISUALSTYLE_ext_lighting_model_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_ext_lighting_model_get", _wrap_Dwg_Object_VISUALSTYLE_ext_lighting_model_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_internal_only_set", _wrap_Dwg_Object_VISUALSTYLE_internal_only_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_internal_only_get", _wrap_Dwg_Object_VISUALSTYLE_internal_only_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_model_set", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_model_get", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_model_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_model_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_model_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_quality_set", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_quality_get", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_lighting_quality_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_lighting_quality_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_color_mode_set", _wrap_Dwg_Object_VISUALSTYLE_face_color_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_color_mode_get", _wrap_Dwg_Object_VISUALSTYLE_face_color_mode_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_color_mode_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_color_mode_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_color_mode_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_color_mode_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_opacity_set", _wrap_Dwg_Object_VISUALSTYLE_face_opacity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_opacity_get", _wrap_Dwg_Object_VISUALSTYLE_face_opacity_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_opacity_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_opacity_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_opacity_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_opacity_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_specular_set", _wrap_Dwg_Object_VISUALSTYLE_face_specular_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_specular_get", _wrap_Dwg_Object_VISUALSTYLE_face_specular_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_specular_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_specular_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_specular_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_specular_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_modifier_set", _wrap_Dwg_Object_VISUALSTYLE_face_modifier_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_modifier_get", _wrap_Dwg_Object_VISUALSTYLE_face_modifier_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_modifier_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_modifier_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_modifier_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_modifier_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_mono_color_set", _wrap_Dwg_Object_VISUALSTYLE_face_mono_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_mono_color_get", _wrap_Dwg_Object_VISUALSTYLE_face_mono_color_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_mono_color_int_set", _wrap_Dwg_Object_VISUALSTYLE_face_mono_color_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_face_mono_color_int_get", _wrap_Dwg_Object_VISUALSTYLE_face_mono_color_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_model_set", _wrap_Dwg_Object_VISUALSTYLE_edge_model_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_model_get", _wrap_Dwg_Object_VISUALSTYLE_edge_model_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_model_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_model_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_model_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_model_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_set", _wrap_Dwg_Object_VISUALSTYLE_edge_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_get", _wrap_Dwg_Object_VISUALSTYLE_edge_style_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_style_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_style_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_color_set", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_color_get", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_color_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_color_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_color_set", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_color_get", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_color_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_color_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_get", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_obscured_ltype_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_get", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_intersection_ltype_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_crease_angle_set", _wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_crease_angle_get", _wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_crease_angle_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_crease_angle_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_modifier_set", _wrap_Dwg_Object_VISUALSTYLE_edge_modifier_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_modifier_get", _wrap_Dwg_Object_VISUALSTYLE_edge_modifier_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_modifier_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_modifier_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_modifier_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_modifier_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_color_set", _wrap_Dwg_Object_VISUALSTYLE_edge_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_color_get", _wrap_Dwg_Object_VISUALSTYLE_edge_color_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_color_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_color_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_color_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_color_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_opacity_set", _wrap_Dwg_Object_VISUALSTYLE_edge_opacity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_opacity_get", _wrap_Dwg_Object_VISUALSTYLE_edge_opacity_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_opacity_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_opacity_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_opacity_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_opacity_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_width_set", _wrap_Dwg_Object_VISUALSTYLE_edge_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_width_get", _wrap_Dwg_Object_VISUALSTYLE_edge_width_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_width_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_width_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_width_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_width_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_overhang_set", _wrap_Dwg_Object_VISUALSTYLE_edge_overhang_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_overhang_get", _wrap_Dwg_Object_VISUALSTYLE_edge_overhang_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_overhang_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_overhang_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_overhang_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_overhang_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_jitter_set", _wrap_Dwg_Object_VISUALSTYLE_edge_jitter_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_jitter_get", _wrap_Dwg_Object_VISUALSTYLE_edge_jitter_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_jitter_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_jitter_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_jitter_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_jitter_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_color_set", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_color_get", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_color_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_width_set", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_width_get", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_silhouette_width_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_halo_gap_set", _wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_halo_gap_get", _wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_halo_gap_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_halo_gap_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_isolines_set", _wrap_Dwg_Object_VISUALSTYLE_edge_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_isolines_get", _wrap_Dwg_Object_VISUALSTYLE_edge_isolines_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_isolines_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_isolines_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_isolines_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_isolines_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set", _wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_get", _wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_do_hide_precision_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_apply_set", _wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_apply_get", _wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_apply_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_style_apply_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_style_apply_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_settings_set", _wrap_Dwg_Object_VISUALSTYLE_display_settings_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_settings_get", _wrap_Dwg_Object_VISUALSTYLE_display_settings_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_settings_int_set", _wrap_Dwg_Object_VISUALSTYLE_display_settings_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_settings_int_get", _wrap_Dwg_Object_VISUALSTYLE_display_settings_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_bl_set", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_bl_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_bl_get", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_bl_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_set", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_get", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_int_set", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_brightness_int_get", _wrap_Dwg_Object_VISUALSTYLE_display_brightness_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_shadow_type_set", _wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_shadow_type_get", _wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_shadow_type_int_set", _wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_display_shadow_type_int_get", _wrap_Dwg_Object_VISUALSTYLE_display_shadow_type_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd2007_45_set", _wrap_Dwg_Object_VISUALSTYLE_bd2007_45_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd2007_45_get", _wrap_Dwg_Object_VISUALSTYLE_bd2007_45_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_num_props_set", _wrap_Dwg_Object_VISUALSTYLE_num_props_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_num_props_get", _wrap_Dwg_Object_VISUALSTYLE_num_props_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1c_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1c_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1c_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1c_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1c_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1c_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1c_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1c_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1d_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1d_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1d_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1d_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1d_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1d_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1d_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1d_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1e_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1e_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1e_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1e_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1e_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1e_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1e_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1e_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1f_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1f_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1f_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1f_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1f_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop1f_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop1f_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop1f_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop20_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop20_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop20_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop20_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop20_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop20_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop20_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop20_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop21_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop21_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop21_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop21_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop21_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop21_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop21_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop21_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop22_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop22_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop22_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop22_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop22_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop22_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop22_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop22_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop23_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop23_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop23_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop23_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop23_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop23_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop23_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop23_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop24_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop24_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop24_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop24_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop24_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop24_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop24_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop24_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop25_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop25_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop25_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop25_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop25_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop25_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop25_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop25_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop26_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop26_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop26_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop26_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop26_int_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop26_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop26_int_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop26_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop27_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop27_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop27_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop27_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop27_int_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop27_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop27_int_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop27_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop28_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop28_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop28_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop28_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop28_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop28_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop28_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop28_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop29_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop29_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop29_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop29_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop29_int_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop29_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop29_int_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop29_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2a_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2a_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2a_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2a_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2a_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2b_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2b_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2b_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2b_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2b_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop2c_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop2c_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop2c_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop2c_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop2c_int_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop2c_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop2c_int_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop2c_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop2d_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop2d_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop2d_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop2d_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop2d_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop2d_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop2d_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop2d_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2e_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2e_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2e_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2e_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2e_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2f_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2f_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2f_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop2f_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop2f_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop30_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop30_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop30_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop30_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop30_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop30_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop30_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop30_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop31_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop31_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop31_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop31_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop31_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop31_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop31_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop31_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop32_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop32_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop32_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop32_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop32_int_set", _wrap_Dwg_Object_VISUALSTYLE_bl_prop32_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bl_prop32_int_get", _wrap_Dwg_Object_VISUALSTYLE_bl_prop32_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop33_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop33_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop33_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop33_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop33_int_set", _wrap_Dwg_Object_VISUALSTYLE_c_prop33_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_c_prop33_int_get", _wrap_Dwg_Object_VISUALSTYLE_c_prop33_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop34_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop34_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop34_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop34_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop34_int_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop34_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop34_int_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop34_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_wiggle_set", _wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_wiggle_get", _wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_wiggle_int_set", _wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_edge_wiggle_int_get", _wrap_Dwg_Object_VISUALSTYLE_edge_wiggle_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_strokes_set", _wrap_Dwg_Object_VISUALSTYLE_strokes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_strokes_get", _wrap_Dwg_Object_VISUALSTYLE_strokes_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_strokes_int_set", _wrap_Dwg_Object_VISUALSTYLE_strokes_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_strokes_int_get", _wrap_Dwg_Object_VISUALSTYLE_strokes_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop37_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop37_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop37_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop37_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop37_int_set", _wrap_Dwg_Object_VISUALSTYLE_b_prop37_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_b_prop37_int_get", _wrap_Dwg_Object_VISUALSTYLE_b_prop37_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop38_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop38_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop38_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop38_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop38_int_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop38_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop38_int_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop38_int_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop39_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop39_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop39_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop39_get, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop39_int_set", _wrap_Dwg_Object_VISUALSTYLE_bd_prop39_int_set, METH_VARARGS, NULL},
	 { "Dwg_Object_VISUALSTYLE_bd_prop39_int_get", _wrap_Dwg_Object_VISUALSTYLE_bd_prop39_int_get, METH_O, NULL},
	 { "new_Dwg_Object_VISUALSTYLE", _wrap_new_Dwg_Object_VISUALSTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_VISUALSTYLE", _wrap_delete_Dwg_Object_VISUALSTYLE, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_swigregister", Dwg_Object_VISUALSTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_VISUALSTYLE_swiginit", Dwg_Object_VISUALSTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_LIGHTLIST_light_parent_set", _wrap_Dwg_LIGHTLIST_light_parent_set, METH_VARARGS, NULL},
	 { "Dwg_LIGHTLIST_light_parent_get", _wrap_Dwg_LIGHTLIST_light_parent_get, METH_O, NULL},
	 { "Dwg_LIGHTLIST_light_name_set", _wrap_Dwg_LIGHTLIST_light_name_set, METH_VARARGS, NULL},
	 { "Dwg_LIGHTLIST_light_name_get", _wrap_Dwg_LIGHTLIST_light_name_get, METH_O, NULL},
	 { "Dwg_LIGHTLIST_light_handle_set", _wrap_Dwg_LIGHTLIST_light_handle_set, METH_VARARGS, NULL},
	 { "Dwg_LIGHTLIST_light_handle_get", _wrap_Dwg_LIGHTLIST_light_handle_get, METH_O, NULL},
	 { "new_Dwg_LIGHTLIST_light", _wrap_new_Dwg_LIGHTLIST_light, METH_NOARGS, NULL},
	 { "delete_Dwg_LIGHTLIST_light", _wrap_delete_Dwg_LIGHTLIST_light, METH_O, NULL},
	 { "Dwg_LIGHTLIST_light_swigregister", Dwg_LIGHTLIST_light_swigregister, METH_O, NULL},
	 { "Dwg_LIGHTLIST_light_swiginit", Dwg_LIGHTLIST_light_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LIGHTLIST_parent_set", _wrap_Dwg_Object_LIGHTLIST_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LIGHTLIST_parent_get", _wrap_Dwg_Object_LIGHTLIST_parent_get, METH_O, NULL},
	 { "Dwg_Object_LIGHTLIST_class_version_set", _wrap_Dwg_Object_LIGHTLIST_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LIGHTLIST_class_version_get", _wrap_Dwg_Object_LIGHTLIST_class_version_get, METH_O, NULL},
	 { "Dwg_Object_LIGHTLIST_num_lights_set", _wrap_Dwg_Object_LIGHTLIST_num_lights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LIGHTLIST_num_lights_get", _wrap_Dwg_Object_LIGHTLIST_num_lights_get, METH_O, NULL},
	 { "Dwg_Object_LIGHTLIST_lights_set", _wrap_Dwg_Object_LIGHTLIST_lights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LIGHTLIST_lights_get", _wrap_Dwg_Object_LIGHTLIST_lights_get, METH_O, NULL},
	 { "new_Dwg_Object_LIGHTLIST", _wrap_new_Dwg_Object_LIGHTLIST, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LIGHTLIST", _wrap_delete_Dwg_Object_LIGHTLIST, METH_O, NULL},
	 { "Dwg_Object_LIGHTLIST_swigregister", Dwg_Object_LIGHTLIST_swigregister, METH_O, NULL},
	 { "Dwg_Object_LIGHTLIST_swiginit", Dwg_Object_LIGHTLIST_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_color_parent_set", _wrap_Dwg_MATERIAL_color_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_color_parent_get", _wrap_Dwg_MATERIAL_color_parent_get, METH_O, NULL},
	 { "Dwg_MATERIAL_color_flag_set", _wrap_Dwg_MATERIAL_color_flag_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_color_flag_get", _wrap_Dwg_MATERIAL_color_flag_get, METH_O, NULL},
	 { "Dwg_MATERIAL_color_factor_set", _wrap_Dwg_MATERIAL_color_factor_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_color_factor_get", _wrap_Dwg_MATERIAL_color_factor_get, METH_O, NULL},
	 { "Dwg_MATERIAL_color_rgb_set", _wrap_Dwg_MATERIAL_color_rgb_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_color_rgb_get", _wrap_Dwg_MATERIAL_color_rgb_get, METH_O, NULL},
	 { "new_Dwg_MATERIAL_color", _wrap_new_Dwg_MATERIAL_color, METH_NOARGS, NULL},
	 { "delete_Dwg_MATERIAL_color", _wrap_delete_Dwg_MATERIAL_color, METH_O, NULL},
	 { "Dwg_MATERIAL_color_swigregister", Dwg_MATERIAL_color_swigregister, METH_O, NULL},
	 { "Dwg_MATERIAL_color_swiginit", Dwg_MATERIAL_color_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_parent_set", _wrap_Dwg_MATERIAL_mapper_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_parent_get", _wrap_Dwg_MATERIAL_mapper_parent_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_blendfactor_set", _wrap_Dwg_MATERIAL_mapper_blendfactor_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_blendfactor_get", _wrap_Dwg_MATERIAL_mapper_blendfactor_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_transmatrix_set", _wrap_Dwg_MATERIAL_mapper_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_transmatrix_get", _wrap_Dwg_MATERIAL_mapper_transmatrix_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_filename_set", _wrap_Dwg_MATERIAL_mapper_filename_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_filename_get", _wrap_Dwg_MATERIAL_mapper_filename_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_color1_set", _wrap_Dwg_MATERIAL_mapper_color1_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_color1_get", _wrap_Dwg_MATERIAL_mapper_color1_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_color2_set", _wrap_Dwg_MATERIAL_mapper_color2_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_color2_get", _wrap_Dwg_MATERIAL_mapper_color2_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_source_set", _wrap_Dwg_MATERIAL_mapper_source_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_source_get", _wrap_Dwg_MATERIAL_mapper_source_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_projection_set", _wrap_Dwg_MATERIAL_mapper_projection_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_projection_get", _wrap_Dwg_MATERIAL_mapper_projection_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_tiling_set", _wrap_Dwg_MATERIAL_mapper_tiling_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_tiling_get", _wrap_Dwg_MATERIAL_mapper_tiling_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_autotransform_set", _wrap_Dwg_MATERIAL_mapper_autotransform_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_autotransform_get", _wrap_Dwg_MATERIAL_mapper_autotransform_get, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_texturemode_set", _wrap_Dwg_MATERIAL_mapper_texturemode_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_mapper_texturemode_get", _wrap_Dwg_MATERIAL_mapper_texturemode_get, METH_O, NULL},
	 { "new_Dwg_MATERIAL_mapper", _wrap_new_Dwg_MATERIAL_mapper, METH_NOARGS, NULL},
	 { "delete_Dwg_MATERIAL_mapper", _wrap_delete_Dwg_MATERIAL_mapper, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_swigregister", Dwg_MATERIAL_mapper_swigregister, METH_O, NULL},
	 { "Dwg_MATERIAL_mapper_swiginit", Dwg_MATERIAL_mapper_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_gentexture_parent_set", _wrap_Dwg_MATERIAL_gentexture_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_gentexture_parent_get", _wrap_Dwg_MATERIAL_gentexture_parent_get, METH_O, NULL},
	 { "Dwg_MATERIAL_gentexture_genprocname_set", _wrap_Dwg_MATERIAL_gentexture_genprocname_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_gentexture_genprocname_get", _wrap_Dwg_MATERIAL_gentexture_genprocname_get, METH_O, NULL},
	 { "Dwg_MATERIAL_gentexture_material_set", _wrap_Dwg_MATERIAL_gentexture_material_set, METH_VARARGS, NULL},
	 { "Dwg_MATERIAL_gentexture_material_get", _wrap_Dwg_MATERIAL_gentexture_material_get, METH_O, NULL},
	 { "new_Dwg_MATERIAL_gentexture", _wrap_new_Dwg_MATERIAL_gentexture, METH_NOARGS, NULL},
	 { "delete_Dwg_MATERIAL_gentexture", _wrap_delete_Dwg_MATERIAL_gentexture, METH_O, NULL},
	 { "Dwg_MATERIAL_gentexture_swigregister", Dwg_MATERIAL_gentexture_swigregister, METH_O, NULL},
	 { "Dwg_MATERIAL_gentexture_swiginit", Dwg_MATERIAL_gentexture_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_parent_set", _wrap_Dwg_Object_MATERIAL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_parent_get", _wrap_Dwg_Object_MATERIAL_parent_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_name_set", _wrap_Dwg_Object_MATERIAL_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_name_get", _wrap_Dwg_Object_MATERIAL_name_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_description_set", _wrap_Dwg_Object_MATERIAL_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_description_get", _wrap_Dwg_Object_MATERIAL_description_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_ambient_color_set", _wrap_Dwg_Object_MATERIAL_ambient_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_ambient_color_get", _wrap_Dwg_Object_MATERIAL_ambient_color_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_diffuse_color_set", _wrap_Dwg_Object_MATERIAL_diffuse_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_diffuse_color_get", _wrap_Dwg_Object_MATERIAL_diffuse_color_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_diffusemap_set", _wrap_Dwg_Object_MATERIAL_diffusemap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_diffusemap_get", _wrap_Dwg_Object_MATERIAL_diffusemap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_specular_gloss_factor_set", _wrap_Dwg_Object_MATERIAL_specular_gloss_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_specular_gloss_factor_get", _wrap_Dwg_Object_MATERIAL_specular_gloss_factor_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_specular_color_set", _wrap_Dwg_Object_MATERIAL_specular_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_specular_color_get", _wrap_Dwg_Object_MATERIAL_specular_color_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_specularmap_set", _wrap_Dwg_Object_MATERIAL_specularmap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_specularmap_get", _wrap_Dwg_Object_MATERIAL_specularmap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_reflectionmap_set", _wrap_Dwg_Object_MATERIAL_reflectionmap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_reflectionmap_get", _wrap_Dwg_Object_MATERIAL_reflectionmap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_opacity_percent_set", _wrap_Dwg_Object_MATERIAL_opacity_percent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_opacity_percent_get", _wrap_Dwg_Object_MATERIAL_opacity_percent_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_opacitymap_set", _wrap_Dwg_Object_MATERIAL_opacitymap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_opacitymap_get", _wrap_Dwg_Object_MATERIAL_opacitymap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_bumpmap_set", _wrap_Dwg_Object_MATERIAL_bumpmap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_bumpmap_get", _wrap_Dwg_Object_MATERIAL_bumpmap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_refraction_index_set", _wrap_Dwg_Object_MATERIAL_refraction_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_refraction_index_get", _wrap_Dwg_Object_MATERIAL_refraction_index_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_refractionmap_set", _wrap_Dwg_Object_MATERIAL_refractionmap_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_refractionmap_get", _wrap_Dwg_Object_MATERIAL_refractionmap_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_color_bleed_scale_set", _wrap_Dwg_Object_MATERIAL_color_bleed_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_color_bleed_scale_get", _wrap_Dwg_Object_MATERIAL_color_bleed_scale_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_indirect_bump_scale_set", _wrap_Dwg_Object_MATERIAL_indirect_bump_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_indirect_bump_scale_get", _wrap_Dwg_Object_MATERIAL_indirect_bump_scale_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_reflectance_scale_set", _wrap_Dwg_Object_MATERIAL_reflectance_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_reflectance_scale_get", _wrap_Dwg_Object_MATERIAL_reflectance_scale_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_transmittance_scale_set", _wrap_Dwg_Object_MATERIAL_transmittance_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_transmittance_scale_get", _wrap_Dwg_Object_MATERIAL_transmittance_scale_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_two_sided_material_set", _wrap_Dwg_Object_MATERIAL_two_sided_material_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_two_sided_material_get", _wrap_Dwg_Object_MATERIAL_two_sided_material_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_luminance_set", _wrap_Dwg_Object_MATERIAL_luminance_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_luminance_get", _wrap_Dwg_Object_MATERIAL_luminance_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_luminance_mode_set", _wrap_Dwg_Object_MATERIAL_luminance_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_luminance_mode_get", _wrap_Dwg_Object_MATERIAL_luminance_mode_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_translucence_set", _wrap_Dwg_Object_MATERIAL_translucence_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_translucence_get", _wrap_Dwg_Object_MATERIAL_translucence_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_self_illumination_set", _wrap_Dwg_Object_MATERIAL_self_illumination_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_self_illumination_get", _wrap_Dwg_Object_MATERIAL_self_illumination_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_reflectivity_set", _wrap_Dwg_Object_MATERIAL_reflectivity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_reflectivity_get", _wrap_Dwg_Object_MATERIAL_reflectivity_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_illumination_model_set", _wrap_Dwg_Object_MATERIAL_illumination_model_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_illumination_model_get", _wrap_Dwg_Object_MATERIAL_illumination_model_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_channel_flags_set", _wrap_Dwg_Object_MATERIAL_channel_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_channel_flags_get", _wrap_Dwg_Object_MATERIAL_channel_flags_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_mode_set", _wrap_Dwg_Object_MATERIAL_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_mode_get", _wrap_Dwg_Object_MATERIAL_mode_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocname_set", _wrap_Dwg_Object_MATERIAL_genprocname_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocname_get", _wrap_Dwg_Object_MATERIAL_genprocname_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genproctype_set", _wrap_Dwg_Object_MATERIAL_genproctype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genproctype_get", _wrap_Dwg_Object_MATERIAL_genproctype_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalbool_set", _wrap_Dwg_Object_MATERIAL_genprocvalbool_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalbool_get", _wrap_Dwg_Object_MATERIAL_genprocvalbool_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalint_set", _wrap_Dwg_Object_MATERIAL_genprocvalint_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalint_get", _wrap_Dwg_Object_MATERIAL_genprocvalint_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalreal_set", _wrap_Dwg_Object_MATERIAL_genprocvalreal_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalreal_get", _wrap_Dwg_Object_MATERIAL_genprocvalreal_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocvaltext_set", _wrap_Dwg_Object_MATERIAL_genprocvaltext_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocvaltext_get", _wrap_Dwg_Object_MATERIAL_genprocvaltext_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalcolor_set", _wrap_Dwg_Object_MATERIAL_genprocvalcolor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genprocvalcolor_get", _wrap_Dwg_Object_MATERIAL_genprocvalcolor_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_genproctableend_set", _wrap_Dwg_Object_MATERIAL_genproctableend_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_genproctableend_get", _wrap_Dwg_Object_MATERIAL_genproctableend_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_num_gentextures_set", _wrap_Dwg_Object_MATERIAL_num_gentextures_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_num_gentextures_get", _wrap_Dwg_Object_MATERIAL_num_gentextures_get, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_gentextures_set", _wrap_Dwg_Object_MATERIAL_gentextures_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MATERIAL_gentextures_get", _wrap_Dwg_Object_MATERIAL_gentextures_get, METH_O, NULL},
	 { "new_Dwg_Object_MATERIAL", _wrap_new_Dwg_Object_MATERIAL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MATERIAL", _wrap_delete_Dwg_Object_MATERIAL, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_swigregister", Dwg_Object_MATERIAL_swigregister, METH_O, NULL},
	 { "Dwg_Object_MATERIAL_swiginit", Dwg_Object_MATERIAL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_OBJECT_PTR_parent_set", _wrap_Dwg_Object_OBJECT_PTR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_OBJECT_PTR_parent_get", _wrap_Dwg_Object_OBJECT_PTR_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_OBJECT_PTR", _wrap_new_Dwg_Object_OBJECT_PTR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_OBJECT_PTR", _wrap_delete_Dwg_Object_OBJECT_PTR, METH_O, NULL},
	 { "Dwg_Object_OBJECT_PTR_swigregister", Dwg_Object_OBJECT_PTR_swigregister, METH_O, NULL},
	 { "Dwg_Object_OBJECT_PTR_swiginit", Dwg_Object_OBJECT_PTR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_parent_set", _wrap_Dwg_Entity_LIGHT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_parent_get", _wrap_Dwg_Entity_LIGHT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_class_version_set", _wrap_Dwg_Entity_LIGHT_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_class_version_get", _wrap_Dwg_Entity_LIGHT_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_name_set", _wrap_Dwg_Entity_LIGHT_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_name_get", _wrap_Dwg_Entity_LIGHT_name_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_type_set", _wrap_Dwg_Entity_LIGHT_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_type_get", _wrap_Dwg_Entity_LIGHT_type_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_status_set", _wrap_Dwg_Entity_LIGHT_status_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_status_get", _wrap_Dwg_Entity_LIGHT_status_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_light_color_set", _wrap_Dwg_Entity_LIGHT_light_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_light_color_get", _wrap_Dwg_Entity_LIGHT_light_color_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_plot_glyph_set", _wrap_Dwg_Entity_LIGHT_plot_glyph_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_plot_glyph_get", _wrap_Dwg_Entity_LIGHT_plot_glyph_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_intensity_set", _wrap_Dwg_Entity_LIGHT_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_intensity_get", _wrap_Dwg_Entity_LIGHT_intensity_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_position_set", _wrap_Dwg_Entity_LIGHT_position_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_position_get", _wrap_Dwg_Entity_LIGHT_position_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_target_set", _wrap_Dwg_Entity_LIGHT_target_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_target_get", _wrap_Dwg_Entity_LIGHT_target_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_type_set", _wrap_Dwg_Entity_LIGHT_attenuation_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_type_get", _wrap_Dwg_Entity_LIGHT_attenuation_type_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_use_attenuation_limits_set", _wrap_Dwg_Entity_LIGHT_use_attenuation_limits_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_use_attenuation_limits_get", _wrap_Dwg_Entity_LIGHT_use_attenuation_limits_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_start_limit_set", _wrap_Dwg_Entity_LIGHT_attenuation_start_limit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_start_limit_get", _wrap_Dwg_Entity_LIGHT_attenuation_start_limit_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_end_limit_set", _wrap_Dwg_Entity_LIGHT_attenuation_end_limit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_attenuation_end_limit_get", _wrap_Dwg_Entity_LIGHT_attenuation_end_limit_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_hotspot_angle_set", _wrap_Dwg_Entity_LIGHT_hotspot_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_hotspot_angle_get", _wrap_Dwg_Entity_LIGHT_hotspot_angle_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_falloff_angle_set", _wrap_Dwg_Entity_LIGHT_falloff_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_falloff_angle_get", _wrap_Dwg_Entity_LIGHT_falloff_angle_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_cast_shadows_set", _wrap_Dwg_Entity_LIGHT_cast_shadows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_cast_shadows_get", _wrap_Dwg_Entity_LIGHT_cast_shadows_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_shadow_type_set", _wrap_Dwg_Entity_LIGHT_shadow_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_shadow_type_get", _wrap_Dwg_Entity_LIGHT_shadow_type_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_shadow_map_size_set", _wrap_Dwg_Entity_LIGHT_shadow_map_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_shadow_map_size_get", _wrap_Dwg_Entity_LIGHT_shadow_map_size_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_shadow_map_softness_set", _wrap_Dwg_Entity_LIGHT_shadow_map_softness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_shadow_map_softness_get", _wrap_Dwg_Entity_LIGHT_shadow_map_softness_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_is_photometric_set", _wrap_Dwg_Entity_LIGHT_is_photometric_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_is_photometric_get", _wrap_Dwg_Entity_LIGHT_is_photometric_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_has_photometric_data_set", _wrap_Dwg_Entity_LIGHT_has_photometric_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_has_photometric_data_get", _wrap_Dwg_Entity_LIGHT_has_photometric_data_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_has_webfile_set", _wrap_Dwg_Entity_LIGHT_has_webfile_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_has_webfile_get", _wrap_Dwg_Entity_LIGHT_has_webfile_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_webfile_set", _wrap_Dwg_Entity_LIGHT_webfile_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_webfile_get", _wrap_Dwg_Entity_LIGHT_webfile_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_physical_intensity_method_set", _wrap_Dwg_Entity_LIGHT_physical_intensity_method_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_physical_intensity_method_get", _wrap_Dwg_Entity_LIGHT_physical_intensity_method_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_physical_intensity_set", _wrap_Dwg_Entity_LIGHT_physical_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_physical_intensity_get", _wrap_Dwg_Entity_LIGHT_physical_intensity_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_illuminance_dist_set", _wrap_Dwg_Entity_LIGHT_illuminance_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_illuminance_dist_get", _wrap_Dwg_Entity_LIGHT_illuminance_dist_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_type_set", _wrap_Dwg_Entity_LIGHT_lamp_color_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_type_get", _wrap_Dwg_Entity_LIGHT_lamp_color_type_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_temp_set", _wrap_Dwg_Entity_LIGHT_lamp_color_temp_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_temp_get", _wrap_Dwg_Entity_LIGHT_lamp_color_temp_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_preset_set", _wrap_Dwg_Entity_LIGHT_lamp_color_preset_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_preset_get", _wrap_Dwg_Entity_LIGHT_lamp_color_preset_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_rgb_set", _wrap_Dwg_Entity_LIGHT_lamp_color_rgb_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_lamp_color_rgb_get", _wrap_Dwg_Entity_LIGHT_lamp_color_rgb_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_rotation_set", _wrap_Dwg_Entity_LIGHT_web_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_rotation_get", _wrap_Dwg_Entity_LIGHT_web_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_extlight_shape_set", _wrap_Dwg_Entity_LIGHT_extlight_shape_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_extlight_shape_get", _wrap_Dwg_Entity_LIGHT_extlight_shape_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_extlight_length_set", _wrap_Dwg_Entity_LIGHT_extlight_length_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_extlight_length_get", _wrap_Dwg_Entity_LIGHT_extlight_length_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_extlight_width_set", _wrap_Dwg_Entity_LIGHT_extlight_width_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_extlight_width_get", _wrap_Dwg_Entity_LIGHT_extlight_width_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_extlight_radius_set", _wrap_Dwg_Entity_LIGHT_extlight_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_extlight_radius_get", _wrap_Dwg_Entity_LIGHT_extlight_radius_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_webfile_type_set", _wrap_Dwg_Entity_LIGHT_webfile_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_webfile_type_get", _wrap_Dwg_Entity_LIGHT_webfile_type_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_symetry_set", _wrap_Dwg_Entity_LIGHT_web_symetry_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_symetry_get", _wrap_Dwg_Entity_LIGHT_web_symetry_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_has_target_grip_set", _wrap_Dwg_Entity_LIGHT_has_target_grip_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_has_target_grip_get", _wrap_Dwg_Entity_LIGHT_has_target_grip_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_flux_set", _wrap_Dwg_Entity_LIGHT_web_flux_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_flux_get", _wrap_Dwg_Entity_LIGHT_web_flux_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_angle1_set", _wrap_Dwg_Entity_LIGHT_web_angle1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_angle1_get", _wrap_Dwg_Entity_LIGHT_web_angle1_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_angle2_set", _wrap_Dwg_Entity_LIGHT_web_angle2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_angle2_get", _wrap_Dwg_Entity_LIGHT_web_angle2_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_angle3_set", _wrap_Dwg_Entity_LIGHT_web_angle3_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_angle3_get", _wrap_Dwg_Entity_LIGHT_web_angle3_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_angle4_set", _wrap_Dwg_Entity_LIGHT_web_angle4_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_angle4_get", _wrap_Dwg_Entity_LIGHT_web_angle4_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_web_angle5_set", _wrap_Dwg_Entity_LIGHT_web_angle5_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_web_angle5_get", _wrap_Dwg_Entity_LIGHT_web_angle5_get, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_glyph_display_type_set", _wrap_Dwg_Entity_LIGHT_glyph_display_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LIGHT_glyph_display_type_get", _wrap_Dwg_Entity_LIGHT_glyph_display_type_get, METH_O, NULL},
	 { "new_Dwg_Entity_LIGHT", _wrap_new_Dwg_Entity_LIGHT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LIGHT", _wrap_delete_Dwg_Entity_LIGHT, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_swigregister", Dwg_Entity_LIGHT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LIGHT_swiginit", Dwg_Entity_LIGHT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_CAMERA_parent_set", _wrap_Dwg_Entity_CAMERA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CAMERA_parent_get", _wrap_Dwg_Entity_CAMERA_parent_get, METH_O, NULL},
	 { "Dwg_Entity_CAMERA_view_set", _wrap_Dwg_Entity_CAMERA_view_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_CAMERA_view_get", _wrap_Dwg_Entity_CAMERA_view_get, METH_O, NULL},
	 { "new_Dwg_Entity_CAMERA", _wrap_new_Dwg_Entity_CAMERA, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_CAMERA", _wrap_delete_Dwg_Entity_CAMERA, METH_O, NULL},
	 { "Dwg_Entity_CAMERA_swigregister", Dwg_Entity_CAMERA_swigregister, METH_O, NULL},
	 { "Dwg_Entity_CAMERA_swiginit", Dwg_Entity_CAMERA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_parent_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_parent_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_parent_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_class_version_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_class_version_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_position_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_position_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_position_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_position_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_radius_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_radius_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_radius_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_landing_gap_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_landing_gap_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_landing_gap_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_notes_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_notes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_notes_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_notes_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_text_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_text_alignment_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_text_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_visible_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_enable_frame_text_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_ins_pt_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_ins_pt_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_alignment_pt_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_mtext_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_mtext_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_mtext_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_is_really_locked_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_size_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_data_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_data_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_flag_get, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_annotative_style_get", _wrap_Dwg_Entity_GEOPOSITIONMARKER_annotative_style_get, METH_O, NULL},
	 { "new_Dwg_Entity_GEOPOSITIONMARKER", _wrap_new_Dwg_Entity_GEOPOSITIONMARKER, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_GEOPOSITIONMARKER", _wrap_delete_Dwg_Entity_GEOPOSITIONMARKER, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_swigregister", Dwg_Entity_GEOPOSITIONMARKER_swigregister, METH_O, NULL},
	 { "Dwg_Entity_GEOPOSITIONMARKER_swiginit", Dwg_Entity_GEOPOSITIONMARKER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_parent_set", _wrap_Dwg_Object_GEOMAPIMAGE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_parent_get", _wrap_Dwg_Object_GEOMAPIMAGE_parent_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_class_version_set", _wrap_Dwg_Object_GEOMAPIMAGE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_class_version_get", _wrap_Dwg_Object_GEOMAPIMAGE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_pt0_set", _wrap_Dwg_Object_GEOMAPIMAGE_pt0_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_pt0_get", _wrap_Dwg_Object_GEOMAPIMAGE_pt0_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_size_set", _wrap_Dwg_Object_GEOMAPIMAGE_image_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_size_get", _wrap_Dwg_Object_GEOMAPIMAGE_image_size_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_display_props_set", _wrap_Dwg_Object_GEOMAPIMAGE_display_props_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_display_props_get", _wrap_Dwg_Object_GEOMAPIMAGE_display_props_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_clipping_set", _wrap_Dwg_Object_GEOMAPIMAGE_clipping_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_clipping_get", _wrap_Dwg_Object_GEOMAPIMAGE_clipping_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_brightness_set", _wrap_Dwg_Object_GEOMAPIMAGE_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_brightness_get", _wrap_Dwg_Object_GEOMAPIMAGE_brightness_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_contrast_set", _wrap_Dwg_Object_GEOMAPIMAGE_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_contrast_get", _wrap_Dwg_Object_GEOMAPIMAGE_contrast_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_fade_set", _wrap_Dwg_Object_GEOMAPIMAGE_fade_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_fade_get", _wrap_Dwg_Object_GEOMAPIMAGE_fade_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_rotation_set", _wrap_Dwg_Object_GEOMAPIMAGE_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_rotation_get", _wrap_Dwg_Object_GEOMAPIMAGE_rotation_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_width_set", _wrap_Dwg_Object_GEOMAPIMAGE_image_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_width_get", _wrap_Dwg_Object_GEOMAPIMAGE_image_width_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_height_set", _wrap_Dwg_Object_GEOMAPIMAGE_image_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_height_get", _wrap_Dwg_Object_GEOMAPIMAGE_image_height_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_name_set", _wrap_Dwg_Object_GEOMAPIMAGE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_name_get", _wrap_Dwg_Object_GEOMAPIMAGE_name_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_file_set", _wrap_Dwg_Object_GEOMAPIMAGE_image_file_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_file_get", _wrap_Dwg_Object_GEOMAPIMAGE_image_file_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_visibility_set", _wrap_Dwg_Object_GEOMAPIMAGE_image_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_image_visibility_get", _wrap_Dwg_Object_GEOMAPIMAGE_image_visibility_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_transparency_set", _wrap_Dwg_Object_GEOMAPIMAGE_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_transparency_get", _wrap_Dwg_Object_GEOMAPIMAGE_transparency_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_height_set", _wrap_Dwg_Object_GEOMAPIMAGE_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_height_get", _wrap_Dwg_Object_GEOMAPIMAGE_height_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_width_set", _wrap_Dwg_Object_GEOMAPIMAGE_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_width_get", _wrap_Dwg_Object_GEOMAPIMAGE_width_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_show_rotation_set", _wrap_Dwg_Object_GEOMAPIMAGE_show_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_show_rotation_get", _wrap_Dwg_Object_GEOMAPIMAGE_show_rotation_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_scale_factor_set", _wrap_Dwg_Object_GEOMAPIMAGE_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_scale_factor_get", _wrap_Dwg_Object_GEOMAPIMAGE_scale_factor_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_brightness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_brightness_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_brightness_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_contrast_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_contrast_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_contrast_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_fade_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_fade_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_fade_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_fade_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_position_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_position_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_position_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_position_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_width_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_width_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_width_get, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_height_set", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_geoimage_height_get", _wrap_Dwg_Object_GEOMAPIMAGE_geoimage_height_get, METH_O, NULL},
	 { "new_Dwg_Object_GEOMAPIMAGE", _wrap_new_Dwg_Object_GEOMAPIMAGE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_GEOMAPIMAGE", _wrap_delete_Dwg_Object_GEOMAPIMAGE, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_swigregister", Dwg_Object_GEOMAPIMAGE_swigregister, METH_O, NULL},
	 { "Dwg_Object_GEOMAPIMAGE_swiginit", Dwg_Object_GEOMAPIMAGE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_parent_set", _wrap_Dwg_Entity_HELIX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_parent_get", _wrap_Dwg_Entity_HELIX_parent_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_flag_set", _wrap_Dwg_Entity_HELIX_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_flag_get", _wrap_Dwg_Entity_HELIX_flag_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_scenario_set", _wrap_Dwg_Entity_HELIX_scenario_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_scenario_get", _wrap_Dwg_Entity_HELIX_scenario_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_degree_set", _wrap_Dwg_Entity_HELIX_degree_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_degree_get", _wrap_Dwg_Entity_HELIX_degree_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_splineflags_set", _wrap_Dwg_Entity_HELIX_splineflags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_splineflags_get", _wrap_Dwg_Entity_HELIX_splineflags_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_knotparam_set", _wrap_Dwg_Entity_HELIX_knotparam_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_knotparam_get", _wrap_Dwg_Entity_HELIX_knotparam_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_fit_tol_set", _wrap_Dwg_Entity_HELIX_fit_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_fit_tol_get", _wrap_Dwg_Entity_HELIX_fit_tol_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_beg_tan_vec_set", _wrap_Dwg_Entity_HELIX_beg_tan_vec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_beg_tan_vec_get", _wrap_Dwg_Entity_HELIX_beg_tan_vec_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_end_tan_vec_set", _wrap_Dwg_Entity_HELIX_end_tan_vec_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_end_tan_vec_get", _wrap_Dwg_Entity_HELIX_end_tan_vec_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_rational_set", _wrap_Dwg_Entity_HELIX_rational_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_rational_get", _wrap_Dwg_Entity_HELIX_rational_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_closed_b_set", _wrap_Dwg_Entity_HELIX_closed_b_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_closed_b_get", _wrap_Dwg_Entity_HELIX_closed_b_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_periodic_set", _wrap_Dwg_Entity_HELIX_periodic_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_periodic_get", _wrap_Dwg_Entity_HELIX_periodic_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_weighted_set", _wrap_Dwg_Entity_HELIX_weighted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_weighted_get", _wrap_Dwg_Entity_HELIX_weighted_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_knot_tol_set", _wrap_Dwg_Entity_HELIX_knot_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_knot_tol_get", _wrap_Dwg_Entity_HELIX_knot_tol_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_ctrl_tol_set", _wrap_Dwg_Entity_HELIX_ctrl_tol_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_ctrl_tol_get", _wrap_Dwg_Entity_HELIX_ctrl_tol_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_num_fit_pts_set", _wrap_Dwg_Entity_HELIX_num_fit_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_num_fit_pts_get", _wrap_Dwg_Entity_HELIX_num_fit_pts_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_fit_pts_set", _wrap_Dwg_Entity_HELIX_fit_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_fit_pts_get", _wrap_Dwg_Entity_HELIX_fit_pts_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_num_knots_set", _wrap_Dwg_Entity_HELIX_num_knots_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_num_knots_get", _wrap_Dwg_Entity_HELIX_num_knots_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_knots_set", _wrap_Dwg_Entity_HELIX_knots_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_knots_get", _wrap_Dwg_Entity_HELIX_knots_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_num_ctrl_pts_set", _wrap_Dwg_Entity_HELIX_num_ctrl_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_num_ctrl_pts_get", _wrap_Dwg_Entity_HELIX_num_ctrl_pts_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_ctrl_pts_set", _wrap_Dwg_Entity_HELIX_ctrl_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_ctrl_pts_get", _wrap_Dwg_Entity_HELIX_ctrl_pts_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_major_version_set", _wrap_Dwg_Entity_HELIX_major_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_major_version_get", _wrap_Dwg_Entity_HELIX_major_version_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_maint_version_set", _wrap_Dwg_Entity_HELIX_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_maint_version_get", _wrap_Dwg_Entity_HELIX_maint_version_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_axis_base_pt_set", _wrap_Dwg_Entity_HELIX_axis_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_axis_base_pt_get", _wrap_Dwg_Entity_HELIX_axis_base_pt_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_start_pt_set", _wrap_Dwg_Entity_HELIX_start_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_start_pt_get", _wrap_Dwg_Entity_HELIX_start_pt_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_axis_vector_set", _wrap_Dwg_Entity_HELIX_axis_vector_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_axis_vector_get", _wrap_Dwg_Entity_HELIX_axis_vector_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_radius_set", _wrap_Dwg_Entity_HELIX_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_radius_get", _wrap_Dwg_Entity_HELIX_radius_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_turns_set", _wrap_Dwg_Entity_HELIX_turns_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_turns_get", _wrap_Dwg_Entity_HELIX_turns_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_turn_height_set", _wrap_Dwg_Entity_HELIX_turn_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_turn_height_get", _wrap_Dwg_Entity_HELIX_turn_height_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_handedness_set", _wrap_Dwg_Entity_HELIX_handedness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_handedness_get", _wrap_Dwg_Entity_HELIX_handedness_get, METH_O, NULL},
	 { "Dwg_Entity_HELIX_constraint_type_set", _wrap_Dwg_Entity_HELIX_constraint_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_HELIX_constraint_type_get", _wrap_Dwg_Entity_HELIX_constraint_type_get, METH_O, NULL},
	 { "new_Dwg_Entity_HELIX", _wrap_new_Dwg_Entity_HELIX, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_HELIX", _wrap_delete_Dwg_Entity_HELIX, METH_O, NULL},
	 { "Dwg_Entity_HELIX_swigregister", Dwg_Entity_HELIX_swigregister, METH_O, NULL},
	 { "Dwg_Entity_HELIX_swiginit", Dwg_Entity_HELIX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_parent_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_parent_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_unknown_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_unknown_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_version_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_version_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_blocks_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_block_size_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_block_size_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sab_size_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sab_size_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_data_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_data_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_point_present_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_point_present_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_point_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_point_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_isolines_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_isolines_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_isoline_present_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_wires_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_wires_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_wires_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_wires_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_silhouettes_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_materials_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_num_materials_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_materials_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_materials_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_guid_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_major_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_major_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_end_marker_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_end_marker_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_history_id_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_history_id_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_modeler_format_version_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bindata_size_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_size_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bindata_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bindata_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bindata_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_u_isolines_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_v_isolines_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_class_version_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_class_version_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_angle_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_angle_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_start_distance_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_draft_end_distance_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_twist_angle_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_twist_angle_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_scale_factor_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_scale_factor_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_align_angle_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_align_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_align_angle_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_align_angle_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_is_solid_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_is_solid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_is_solid_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_is_solid_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_alignment_flags_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_flags_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_flags_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_flags_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_align_start_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_align_start_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_align_start_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_align_start_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bank_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bank_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_bank_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_bank_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_base_point_set_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_base_point_set_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_base_point_set_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_transform_computed_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_transform_computed_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_reference_vector_for_controlling_twist_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_entity_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_path_entity_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_path_entity_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_vector_get, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_get", _wrap_Dwg_Entity_EXTRUDEDSURFACE_sweep_transmatrix_get, METH_O, NULL},
	 { "new_Dwg_Entity_EXTRUDEDSURFACE", _wrap_new_Dwg_Entity_EXTRUDEDSURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_EXTRUDEDSURFACE", _wrap_delete_Dwg_Entity_EXTRUDEDSURFACE, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_swigregister", Dwg_Entity_EXTRUDEDSURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_EXTRUDEDSURFACE_swiginit", Dwg_Entity_EXTRUDEDSURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_parent_set", _wrap_Dwg_Entity_SWEPTSURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_parent_get", _wrap_Dwg_Entity_SWEPTSURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty_set", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty_get", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_unknown_set", _wrap_Dwg_Entity_SWEPTSURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_unknown_get", _wrap_Dwg_Entity_SWEPTSURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_version_set", _wrap_Dwg_Entity_SWEPTSURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_version_get", _wrap_Dwg_Entity_SWEPTSURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_blocks_set", _wrap_Dwg_Entity_SWEPTSURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_blocks_get", _wrap_Dwg_Entity_SWEPTSURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_block_size_set", _wrap_Dwg_Entity_SWEPTSURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_block_size_get", _wrap_Dwg_Entity_SWEPTSURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_encr_sat_data_set", _wrap_Dwg_Entity_SWEPTSURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_encr_sat_data_get", _wrap_Dwg_Entity_SWEPTSURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sab_size_set", _wrap_Dwg_Entity_SWEPTSURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sab_size_get", _wrap_Dwg_Entity_SWEPTSURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_data_set", _wrap_Dwg_Entity_SWEPTSURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_data_get", _wrap_Dwg_Entity_SWEPTSURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_SWEPTSURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_SWEPTSURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_point_present_set", _wrap_Dwg_Entity_SWEPTSURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_point_present_get", _wrap_Dwg_Entity_SWEPTSURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_point_set", _wrap_Dwg_Entity_SWEPTSURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_point_get", _wrap_Dwg_Entity_SWEPTSURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_isolines_set", _wrap_Dwg_Entity_SWEPTSURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_isolines_get", _wrap_Dwg_Entity_SWEPTSURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_isoline_present_set", _wrap_Dwg_Entity_SWEPTSURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_isoline_present_get", _wrap_Dwg_Entity_SWEPTSURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_wires_set", _wrap_Dwg_Entity_SWEPTSURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_wires_get", _wrap_Dwg_Entity_SWEPTSURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_wires_set", _wrap_Dwg_Entity_SWEPTSURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_wires_get", _wrap_Dwg_Entity_SWEPTSURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_silhouettes_set", _wrap_Dwg_Entity_SWEPTSURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_silhouettes_get", _wrap_Dwg_Entity_SWEPTSURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_silhouettes_set", _wrap_Dwg_Entity_SWEPTSURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_silhouettes_get", _wrap_Dwg_Entity_SWEPTSURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_SWEPTSURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty2_set", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty2_get", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_extra_acis_data_set", _wrap_Dwg_Entity_SWEPTSURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_extra_acis_data_get", _wrap_Dwg_Entity_SWEPTSURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_materials_set", _wrap_Dwg_Entity_SWEPTSURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_num_materials_get", _wrap_Dwg_Entity_SWEPTSURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_materials_set", _wrap_Dwg_Entity_SWEPTSURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_materials_get", _wrap_Dwg_Entity_SWEPTSURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_guid_set", _wrap_Dwg_Entity_SWEPTSURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_guid_get", _wrap_Dwg_Entity_SWEPTSURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_major_set", _wrap_Dwg_Entity_SWEPTSURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_major_get", _wrap_Dwg_Entity_SWEPTSURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_minor1_set", _wrap_Dwg_Entity_SWEPTSURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_minor1_get", _wrap_Dwg_Entity_SWEPTSURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_minor2_set", _wrap_Dwg_Entity_SWEPTSURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_minor2_get", _wrap_Dwg_Entity_SWEPTSURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_bytes_set", _wrap_Dwg_Entity_SWEPTSURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_revision_bytes_get", _wrap_Dwg_Entity_SWEPTSURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_end_marker_set", _wrap_Dwg_Entity_SWEPTSURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_end_marker_get", _wrap_Dwg_Entity_SWEPTSURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_history_id_set", _wrap_Dwg_Entity_SWEPTSURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_history_id_get", _wrap_Dwg_Entity_SWEPTSURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_has_revision_guid_set", _wrap_Dwg_Entity_SWEPTSURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_has_revision_guid_get", _wrap_Dwg_Entity_SWEPTSURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_SWEPTSURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_modeler_format_version_set", _wrap_Dwg_Entity_SWEPTSURFACE_modeler_format_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_modeler_format_version_get", _wrap_Dwg_Entity_SWEPTSURFACE_modeler_format_version_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_u_isolines_set", _wrap_Dwg_Entity_SWEPTSURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_u_isolines_get", _wrap_Dwg_Entity_SWEPTSURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_v_isolines_set", _wrap_Dwg_Entity_SWEPTSURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_v_isolines_get", _wrap_Dwg_Entity_SWEPTSURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_class_version_set", _wrap_Dwg_Entity_SWEPTSURFACE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_class_version_get", _wrap_Dwg_Entity_SWEPTSURFACE_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_id_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_id_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweepdata_size_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweepdata_size_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_size_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweepdata_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweepdata_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweepdata_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_id_set", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_id_get", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_id_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_pathdata_size_set", _wrap_Dwg_Entity_SWEPTSURFACE_pathdata_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_pathdata_size_get", _wrap_Dwg_Entity_SWEPTSURFACE_pathdata_size_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_pathdata_set", _wrap_Dwg_Entity_SWEPTSURFACE_pathdata_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_pathdata_get", _wrap_Dwg_Entity_SWEPTSURFACE_pathdata_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_angle_set", _wrap_Dwg_Entity_SWEPTSURFACE_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_angle_get", _wrap_Dwg_Entity_SWEPTSURFACE_draft_angle_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_start_distance_set", _wrap_Dwg_Entity_SWEPTSURFACE_draft_start_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_start_distance_get", _wrap_Dwg_Entity_SWEPTSURFACE_draft_start_distance_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_end_distance_set", _wrap_Dwg_Entity_SWEPTSURFACE_draft_end_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_draft_end_distance_get", _wrap_Dwg_Entity_SWEPTSURFACE_draft_end_distance_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_twist_angle_set", _wrap_Dwg_Entity_SWEPTSURFACE_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_twist_angle_get", _wrap_Dwg_Entity_SWEPTSURFACE_twist_angle_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_scale_factor_set", _wrap_Dwg_Entity_SWEPTSURFACE_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_scale_factor_get", _wrap_Dwg_Entity_SWEPTSURFACE_scale_factor_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_align_angle_set", _wrap_Dwg_Entity_SWEPTSURFACE_align_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_align_angle_get", _wrap_Dwg_Entity_SWEPTSURFACE_align_angle_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_get", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_is_solid_set", _wrap_Dwg_Entity_SWEPTSURFACE_is_solid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_is_solid_get", _wrap_Dwg_Entity_SWEPTSURFACE_is_solid_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_alignment_flags_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_flags_set", _wrap_Dwg_Entity_SWEPTSURFACE_path_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_flags_get", _wrap_Dwg_Entity_SWEPTSURFACE_path_flags_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_align_start_set", _wrap_Dwg_Entity_SWEPTSURFACE_align_start_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_align_start_get", _wrap_Dwg_Entity_SWEPTSURFACE_align_start_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_bank_set", _wrap_Dwg_Entity_SWEPTSURFACE_bank_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_bank_get", _wrap_Dwg_Entity_SWEPTSURFACE_bank_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_base_point_set_set", _wrap_Dwg_Entity_SWEPTSURFACE_base_point_set_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_base_point_set_get", _wrap_Dwg_Entity_SWEPTSURFACE_base_point_set_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_transform_computed_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_get", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_transform_computed_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set", _wrap_Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_get", _wrap_Dwg_Entity_SWEPTSURFACE_reference_vector_for_controlling_twist_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_set", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_sweep_entity_get", _wrap_Dwg_Entity_SWEPTSURFACE_sweep_entity_get, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_set", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_path_entity_get", _wrap_Dwg_Entity_SWEPTSURFACE_path_entity_get, METH_O, NULL},
	 { "new_Dwg_Entity_SWEPTSURFACE", _wrap_new_Dwg_Entity_SWEPTSURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_SWEPTSURFACE", _wrap_delete_Dwg_Entity_SWEPTSURFACE, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_swigregister", Dwg_Entity_SWEPTSURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_SWEPTSURFACE_swiginit", Dwg_Entity_SWEPTSURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_parent_set", _wrap_Dwg_Entity_LOFTEDSURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_parent_get", _wrap_Dwg_Entity_LOFTEDSURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty_set", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty_get", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_unknown_set", _wrap_Dwg_Entity_LOFTEDSURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_unknown_get", _wrap_Dwg_Entity_LOFTEDSURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_version_set", _wrap_Dwg_Entity_LOFTEDSURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_version_get", _wrap_Dwg_Entity_LOFTEDSURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_blocks_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_blocks_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_block_size_set", _wrap_Dwg_Entity_LOFTEDSURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_block_size_get", _wrap_Dwg_Entity_LOFTEDSURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set", _wrap_Dwg_Entity_LOFTEDSURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_encr_sat_data_get", _wrap_Dwg_Entity_LOFTEDSURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_sab_size_set", _wrap_Dwg_Entity_LOFTEDSURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_sab_size_get", _wrap_Dwg_Entity_LOFTEDSURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_data_set", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_data_get", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_LOFTEDSURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_point_present_set", _wrap_Dwg_Entity_LOFTEDSURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_point_present_get", _wrap_Dwg_Entity_LOFTEDSURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_point_set", _wrap_Dwg_Entity_LOFTEDSURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_point_get", _wrap_Dwg_Entity_LOFTEDSURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_isolines_set", _wrap_Dwg_Entity_LOFTEDSURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_isolines_get", _wrap_Dwg_Entity_LOFTEDSURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_isoline_present_set", _wrap_Dwg_Entity_LOFTEDSURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_isoline_present_get", _wrap_Dwg_Entity_LOFTEDSURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_wires_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_wires_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_wires_set", _wrap_Dwg_Entity_LOFTEDSURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_wires_get", _wrap_Dwg_Entity_LOFTEDSURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_silhouettes_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_silhouettes_set", _wrap_Dwg_Entity_LOFTEDSURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_silhouettes_get", _wrap_Dwg_Entity_LOFTEDSURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_LOFTEDSURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty2_set", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty2_get", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set", _wrap_Dwg_Entity_LOFTEDSURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_extra_acis_data_get", _wrap_Dwg_Entity_LOFTEDSURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_materials_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_materials_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_materials_set", _wrap_Dwg_Entity_LOFTEDSURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_materials_get", _wrap_Dwg_Entity_LOFTEDSURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_guid_set", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_guid_get", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_major_set", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_major_get", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_minor1_set", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_minor1_get", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_minor2_set", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_minor2_get", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_bytes_set", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_revision_bytes_get", _wrap_Dwg_Entity_LOFTEDSURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_marker_set", _wrap_Dwg_Entity_LOFTEDSURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_marker_get", _wrap_Dwg_Entity_LOFTEDSURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_history_id_set", _wrap_Dwg_Entity_LOFTEDSURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_history_id_get", _wrap_Dwg_Entity_LOFTEDSURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set", _wrap_Dwg_Entity_LOFTEDSURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_has_revision_guid_get", _wrap_Dwg_Entity_LOFTEDSURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_LOFTEDSURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set", _wrap_Dwg_Entity_LOFTEDSURFACE_modeler_format_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_modeler_format_version_get", _wrap_Dwg_Entity_LOFTEDSURFACE_modeler_format_version_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_u_isolines_set", _wrap_Dwg_Entity_LOFTEDSURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_u_isolines_get", _wrap_Dwg_Entity_LOFTEDSURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_v_isolines_set", _wrap_Dwg_Entity_LOFTEDSURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_v_isolines_get", _wrap_Dwg_Entity_LOFTEDSURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set", _wrap_Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_get", _wrap_Dwg_Entity_LOFTEDSURFACE_loft_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set", _wrap_Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_get", _wrap_Dwg_Entity_LOFTEDSURFACE_plane_normal_lofting_type_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set", _wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_start_draft_angle_get", _wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_angle_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set", _wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_draft_angle_get", _wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_angle_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set", _wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_get", _wrap_Dwg_Entity_LOFTEDSURFACE_start_draft_magnitude_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set", _wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_get", _wrap_Dwg_Entity_LOFTEDSURFACE_end_draft_magnitude_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set", _wrap_Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_get", _wrap_Dwg_Entity_LOFTEDSURFACE_arc_length_parameterization_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_no_twist_set", _wrap_Dwg_Entity_LOFTEDSURFACE_no_twist_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_no_twist_get", _wrap_Dwg_Entity_LOFTEDSURFACE_no_twist_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_align_direction_set", _wrap_Dwg_Entity_LOFTEDSURFACE_align_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_align_direction_get", _wrap_Dwg_Entity_LOFTEDSURFACE_align_direction_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set", _wrap_Dwg_Entity_LOFTEDSURFACE_simple_surfaces_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_simple_surfaces_get", _wrap_Dwg_Entity_LOFTEDSURFACE_simple_surfaces_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set", _wrap_Dwg_Entity_LOFTEDSURFACE_closed_surfaces_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_closed_surfaces_get", _wrap_Dwg_Entity_LOFTEDSURFACE_closed_surfaces_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_solid_set", _wrap_Dwg_Entity_LOFTEDSURFACE_solid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_solid_get", _wrap_Dwg_Entity_LOFTEDSURFACE_solid_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_ruled_surface_set", _wrap_Dwg_Entity_LOFTEDSURFACE_ruled_surface_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_ruled_surface_get", _wrap_Dwg_Entity_LOFTEDSURFACE_ruled_surface_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_virtual_guide_set", _wrap_Dwg_Entity_LOFTEDSURFACE_virtual_guide_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_virtual_guide_get", _wrap_Dwg_Entity_LOFTEDSURFACE_virtual_guide_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_cross_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_cross_sections_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_cross_sections_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set", _wrap_Dwg_Entity_LOFTEDSURFACE_num_guide_curves_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_num_guide_curves_get", _wrap_Dwg_Entity_LOFTEDSURFACE_num_guide_curves_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_cross_sections_set", _wrap_Dwg_Entity_LOFTEDSURFACE_cross_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_cross_sections_get", _wrap_Dwg_Entity_LOFTEDSURFACE_cross_sections_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_guide_curves_set", _wrap_Dwg_Entity_LOFTEDSURFACE_guide_curves_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_guide_curves_get", _wrap_Dwg_Entity_LOFTEDSURFACE_guide_curves_get, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_path_curve_set", _wrap_Dwg_Entity_LOFTEDSURFACE_path_curve_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_path_curve_get", _wrap_Dwg_Entity_LOFTEDSURFACE_path_curve_get, METH_O, NULL},
	 { "new_Dwg_Entity_LOFTEDSURFACE", _wrap_new_Dwg_Entity_LOFTEDSURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LOFTEDSURFACE", _wrap_delete_Dwg_Entity_LOFTEDSURFACE, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_swigregister", Dwg_Entity_LOFTEDSURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LOFTEDSURFACE_swiginit", Dwg_Entity_LOFTEDSURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_parent_set", _wrap_Dwg_Entity_NURBSURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_parent_get", _wrap_Dwg_Entity_NURBSURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty_set", _wrap_Dwg_Entity_NURBSURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty_get", _wrap_Dwg_Entity_NURBSURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_unknown_set", _wrap_Dwg_Entity_NURBSURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_unknown_get", _wrap_Dwg_Entity_NURBSURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_version_set", _wrap_Dwg_Entity_NURBSURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_version_get", _wrap_Dwg_Entity_NURBSURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_blocks_set", _wrap_Dwg_Entity_NURBSURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_blocks_get", _wrap_Dwg_Entity_NURBSURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_block_size_set", _wrap_Dwg_Entity_NURBSURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_block_size_get", _wrap_Dwg_Entity_NURBSURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_encr_sat_data_set", _wrap_Dwg_Entity_NURBSURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_encr_sat_data_get", _wrap_Dwg_Entity_NURBSURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_sab_size_set", _wrap_Dwg_Entity_NURBSURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_sab_size_get", _wrap_Dwg_Entity_NURBSURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_data_set", _wrap_Dwg_Entity_NURBSURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_data_get", _wrap_Dwg_Entity_NURBSURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_NURBSURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_NURBSURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_point_present_set", _wrap_Dwg_Entity_NURBSURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_point_present_get", _wrap_Dwg_Entity_NURBSURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_point_set", _wrap_Dwg_Entity_NURBSURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_point_get", _wrap_Dwg_Entity_NURBSURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_isolines_set", _wrap_Dwg_Entity_NURBSURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_isolines_get", _wrap_Dwg_Entity_NURBSURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_isoline_present_set", _wrap_Dwg_Entity_NURBSURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_isoline_present_get", _wrap_Dwg_Entity_NURBSURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_wires_set", _wrap_Dwg_Entity_NURBSURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_wires_get", _wrap_Dwg_Entity_NURBSURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_wires_set", _wrap_Dwg_Entity_NURBSURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_wires_get", _wrap_Dwg_Entity_NURBSURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_silhouettes_set", _wrap_Dwg_Entity_NURBSURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_silhouettes_get", _wrap_Dwg_Entity_NURBSURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_silhouettes_set", _wrap_Dwg_Entity_NURBSURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_silhouettes_get", _wrap_Dwg_Entity_NURBSURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_NURBSURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_NURBSURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty2_set", _wrap_Dwg_Entity_NURBSURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty2_get", _wrap_Dwg_Entity_NURBSURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_extra_acis_data_set", _wrap_Dwg_Entity_NURBSURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_extra_acis_data_get", _wrap_Dwg_Entity_NURBSURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_materials_set", _wrap_Dwg_Entity_NURBSURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_num_materials_get", _wrap_Dwg_Entity_NURBSURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_materials_set", _wrap_Dwg_Entity_NURBSURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_materials_get", _wrap_Dwg_Entity_NURBSURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_guid_set", _wrap_Dwg_Entity_NURBSURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_guid_get", _wrap_Dwg_Entity_NURBSURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_major_set", _wrap_Dwg_Entity_NURBSURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_major_get", _wrap_Dwg_Entity_NURBSURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_minor1_set", _wrap_Dwg_Entity_NURBSURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_minor1_get", _wrap_Dwg_Entity_NURBSURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_minor2_set", _wrap_Dwg_Entity_NURBSURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_minor2_get", _wrap_Dwg_Entity_NURBSURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_bytes_set", _wrap_Dwg_Entity_NURBSURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_revision_bytes_get", _wrap_Dwg_Entity_NURBSURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_end_marker_set", _wrap_Dwg_Entity_NURBSURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_end_marker_get", _wrap_Dwg_Entity_NURBSURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_history_id_set", _wrap_Dwg_Entity_NURBSURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_history_id_get", _wrap_Dwg_Entity_NURBSURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_has_revision_guid_set", _wrap_Dwg_Entity_NURBSURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_has_revision_guid_get", _wrap_Dwg_Entity_NURBSURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_NURBSURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_NURBSURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_u_isolines_set", _wrap_Dwg_Entity_NURBSURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_u_isolines_get", _wrap_Dwg_Entity_NURBSURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_v_isolines_set", _wrap_Dwg_Entity_NURBSURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_v_isolines_get", _wrap_Dwg_Entity_NURBSURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_short170_set", _wrap_Dwg_Entity_NURBSURFACE_short170_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_short170_get", _wrap_Dwg_Entity_NURBSURFACE_short170_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_cv_hull_display_set", _wrap_Dwg_Entity_NURBSURFACE_cv_hull_display_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_cv_hull_display_get", _wrap_Dwg_Entity_NURBSURFACE_cv_hull_display_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_uvec1_set", _wrap_Dwg_Entity_NURBSURFACE_uvec1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_uvec1_get", _wrap_Dwg_Entity_NURBSURFACE_uvec1_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_vvec1_set", _wrap_Dwg_Entity_NURBSURFACE_vvec1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_vvec1_get", _wrap_Dwg_Entity_NURBSURFACE_vvec1_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_uvec2_set", _wrap_Dwg_Entity_NURBSURFACE_uvec2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_uvec2_get", _wrap_Dwg_Entity_NURBSURFACE_uvec2_get, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_vvec2_set", _wrap_Dwg_Entity_NURBSURFACE_vvec2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NURBSURFACE_vvec2_get", _wrap_Dwg_Entity_NURBSURFACE_vvec2_get, METH_O, NULL},
	 { "new_Dwg_Entity_NURBSURFACE", _wrap_new_Dwg_Entity_NURBSURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_NURBSURFACE", _wrap_delete_Dwg_Entity_NURBSURFACE, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_swigregister", Dwg_Entity_NURBSURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_NURBSURFACE_swiginit", Dwg_Entity_NURBSURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_parent_set", _wrap_Dwg_Entity_PLANESURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_parent_get", _wrap_Dwg_Entity_PLANESURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty_set", _wrap_Dwg_Entity_PLANESURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty_get", _wrap_Dwg_Entity_PLANESURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_unknown_set", _wrap_Dwg_Entity_PLANESURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_unknown_get", _wrap_Dwg_Entity_PLANESURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_version_set", _wrap_Dwg_Entity_PLANESURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_version_get", _wrap_Dwg_Entity_PLANESURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_blocks_set", _wrap_Dwg_Entity_PLANESURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_blocks_get", _wrap_Dwg_Entity_PLANESURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_block_size_set", _wrap_Dwg_Entity_PLANESURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_block_size_get", _wrap_Dwg_Entity_PLANESURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_encr_sat_data_set", _wrap_Dwg_Entity_PLANESURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_encr_sat_data_get", _wrap_Dwg_Entity_PLANESURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_sab_size_set", _wrap_Dwg_Entity_PLANESURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_sab_size_get", _wrap_Dwg_Entity_PLANESURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_data_set", _wrap_Dwg_Entity_PLANESURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_data_get", _wrap_Dwg_Entity_PLANESURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_PLANESURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_PLANESURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_point_present_set", _wrap_Dwg_Entity_PLANESURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_point_present_get", _wrap_Dwg_Entity_PLANESURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_point_set", _wrap_Dwg_Entity_PLANESURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_point_get", _wrap_Dwg_Entity_PLANESURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_isolines_set", _wrap_Dwg_Entity_PLANESURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_isolines_get", _wrap_Dwg_Entity_PLANESURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_isoline_present_set", _wrap_Dwg_Entity_PLANESURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_isoline_present_get", _wrap_Dwg_Entity_PLANESURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_wires_set", _wrap_Dwg_Entity_PLANESURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_wires_get", _wrap_Dwg_Entity_PLANESURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_wires_set", _wrap_Dwg_Entity_PLANESURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_wires_get", _wrap_Dwg_Entity_PLANESURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_silhouettes_set", _wrap_Dwg_Entity_PLANESURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_silhouettes_get", _wrap_Dwg_Entity_PLANESURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_silhouettes_set", _wrap_Dwg_Entity_PLANESURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_silhouettes_get", _wrap_Dwg_Entity_PLANESURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_PLANESURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_PLANESURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty2_set", _wrap_Dwg_Entity_PLANESURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty2_get", _wrap_Dwg_Entity_PLANESURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_extra_acis_data_set", _wrap_Dwg_Entity_PLANESURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_extra_acis_data_get", _wrap_Dwg_Entity_PLANESURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_materials_set", _wrap_Dwg_Entity_PLANESURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_num_materials_get", _wrap_Dwg_Entity_PLANESURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_materials_set", _wrap_Dwg_Entity_PLANESURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_materials_get", _wrap_Dwg_Entity_PLANESURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_guid_set", _wrap_Dwg_Entity_PLANESURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_guid_get", _wrap_Dwg_Entity_PLANESURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_major_set", _wrap_Dwg_Entity_PLANESURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_major_get", _wrap_Dwg_Entity_PLANESURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_minor1_set", _wrap_Dwg_Entity_PLANESURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_minor1_get", _wrap_Dwg_Entity_PLANESURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_minor2_set", _wrap_Dwg_Entity_PLANESURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_minor2_get", _wrap_Dwg_Entity_PLANESURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_bytes_set", _wrap_Dwg_Entity_PLANESURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_revision_bytes_get", _wrap_Dwg_Entity_PLANESURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_end_marker_set", _wrap_Dwg_Entity_PLANESURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_end_marker_get", _wrap_Dwg_Entity_PLANESURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_history_id_set", _wrap_Dwg_Entity_PLANESURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_history_id_get", _wrap_Dwg_Entity_PLANESURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_has_revision_guid_set", _wrap_Dwg_Entity_PLANESURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_has_revision_guid_get", _wrap_Dwg_Entity_PLANESURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_PLANESURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_PLANESURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_modeler_format_version_set", _wrap_Dwg_Entity_PLANESURFACE_modeler_format_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_modeler_format_version_get", _wrap_Dwg_Entity_PLANESURFACE_modeler_format_version_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_u_isolines_set", _wrap_Dwg_Entity_PLANESURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_u_isolines_get", _wrap_Dwg_Entity_PLANESURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_v_isolines_set", _wrap_Dwg_Entity_PLANESURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_v_isolines_get", _wrap_Dwg_Entity_PLANESURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_class_version_set", _wrap_Dwg_Entity_PLANESURFACE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_PLANESURFACE_class_version_get", _wrap_Dwg_Entity_PLANESURFACE_class_version_get, METH_O, NULL},
	 { "new_Dwg_Entity_PLANESURFACE", _wrap_new_Dwg_Entity_PLANESURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_PLANESURFACE", _wrap_delete_Dwg_Entity_PLANESURFACE, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_swigregister", Dwg_Entity_PLANESURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_PLANESURFACE_swiginit", Dwg_Entity_PLANESURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_parent_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_parent_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_parent_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_unknown_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_unknown_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_unknown_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_version_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_version_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_version_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_blocks_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_blocks_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_blocks_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_block_size_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_block_size_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_block_size_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_sab_size_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_sab_size_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_sab_size_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_data_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_data_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_point_present_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_point_present_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_point_present_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_point_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_point_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_point_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_isolines_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_isolines_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_isoline_present_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_isoline_present_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_isoline_present_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_wires_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_wires_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_wires_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_wires_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_wires_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_wires_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_silhouettes_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_silhouettes_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_silhouettes_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set", _wrap_Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_get", _wrap_Dwg_Entity_REVOLVEDSURFACE__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty2_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_materials_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_num_materials_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_num_materials_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_materials_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_materials_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_materials_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_guid_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_guid_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_major_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_major_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_major_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_minor1_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_minor2_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revision_bytes_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_end_marker_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_end_marker_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_end_marker_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_history_id_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_history_id_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_history_id_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_modeler_format_version_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_u_isolines_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_u_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_u_isolines_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_u_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_v_isolines_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_v_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_v_isolines_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_v_isolines_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_class_version_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_class_version_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_id_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_id_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_id_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_id_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_axis_point_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_axis_point_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_axis_point_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_axis_point_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_axis_vector_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_axis_vector_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_axis_vector_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_axis_vector_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revolve_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revolve_angle_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revolve_angle_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_start_angle_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_start_angle_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_start_angle_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_revolved_entity_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_angle_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_angle_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_angle_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_start_distance_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_draft_end_distance_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_twist_angle_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_twist_angle_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_twist_angle_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_solid_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_solid_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_solid_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_solid_get, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set", _wrap_Dwg_Entity_REVOLVEDSURFACE_close_to_axis_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_close_to_axis_get", _wrap_Dwg_Entity_REVOLVEDSURFACE_close_to_axis_get, METH_O, NULL},
	 { "new_Dwg_Entity_REVOLVEDSURFACE", _wrap_new_Dwg_Entity_REVOLVEDSURFACE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_REVOLVEDSURFACE", _wrap_delete_Dwg_Entity_REVOLVEDSURFACE, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_swigregister", Dwg_Entity_REVOLVEDSURFACE_swigregister, METH_O, NULL},
	 { "Dwg_Entity_REVOLVEDSURFACE_swiginit", Dwg_Entity_REVOLVEDSURFACE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_MESH_edge_parent_set", _wrap_Dwg_MESH_edge_parent_set, METH_VARARGS, NULL},
	 { "Dwg_MESH_edge_parent_get", _wrap_Dwg_MESH_edge_parent_get, METH_O, NULL},
	 { "Dwg_MESH_edge_idxfrom_set", _wrap_Dwg_MESH_edge_idxfrom_set, METH_VARARGS, NULL},
	 { "Dwg_MESH_edge_idxfrom_get", _wrap_Dwg_MESH_edge_idxfrom_get, METH_O, NULL},
	 { "Dwg_MESH_edge_idxto_set", _wrap_Dwg_MESH_edge_idxto_set, METH_VARARGS, NULL},
	 { "Dwg_MESH_edge_idxto_get", _wrap_Dwg_MESH_edge_idxto_get, METH_O, NULL},
	 { "new_Dwg_MESH_edge", _wrap_new_Dwg_MESH_edge, METH_NOARGS, NULL},
	 { "delete_Dwg_MESH_edge", _wrap_delete_Dwg_MESH_edge, METH_O, NULL},
	 { "Dwg_MESH_edge_swigregister", Dwg_MESH_edge_swigregister, METH_O, NULL},
	 { "Dwg_MESH_edge_swiginit", Dwg_MESH_edge_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_parent_set", _wrap_Dwg_Entity_MESH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_parent_get", _wrap_Dwg_Entity_MESH_parent_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_dlevel_set", _wrap_Dwg_Entity_MESH_dlevel_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_dlevel_get", _wrap_Dwg_Entity_MESH_dlevel_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_is_watertight_set", _wrap_Dwg_Entity_MESH_is_watertight_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_is_watertight_get", _wrap_Dwg_Entity_MESH_is_watertight_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_num_subdiv_vertex_set", _wrap_Dwg_Entity_MESH_num_subdiv_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_num_subdiv_vertex_get", _wrap_Dwg_Entity_MESH_num_subdiv_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_subdiv_vertex_set", _wrap_Dwg_Entity_MESH_subdiv_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_subdiv_vertex_get", _wrap_Dwg_Entity_MESH_subdiv_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_num_vertex_set", _wrap_Dwg_Entity_MESH_num_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_num_vertex_get", _wrap_Dwg_Entity_MESH_num_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_vertex_set", _wrap_Dwg_Entity_MESH_vertex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_vertex_get", _wrap_Dwg_Entity_MESH_vertex_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_num_faces_set", _wrap_Dwg_Entity_MESH_num_faces_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_num_faces_get", _wrap_Dwg_Entity_MESH_num_faces_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_faces_set", _wrap_Dwg_Entity_MESH_faces_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_faces_get", _wrap_Dwg_Entity_MESH_faces_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_num_edges_set", _wrap_Dwg_Entity_MESH_num_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_num_edges_get", _wrap_Dwg_Entity_MESH_num_edges_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_edges_set", _wrap_Dwg_Entity_MESH_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_edges_get", _wrap_Dwg_Entity_MESH_edges_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_num_crease_set", _wrap_Dwg_Entity_MESH_num_crease_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_num_crease_get", _wrap_Dwg_Entity_MESH_num_crease_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_crease_set", _wrap_Dwg_Entity_MESH_crease_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_crease_get", _wrap_Dwg_Entity_MESH_crease_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_unknown_b1_set", _wrap_Dwg_Entity_MESH_unknown_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_unknown_b1_get", _wrap_Dwg_Entity_MESH_unknown_b1_get, METH_O, NULL},
	 { "Dwg_Entity_MESH_unknown_b2_set", _wrap_Dwg_Entity_MESH_unknown_b2_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_MESH_unknown_b2_get", _wrap_Dwg_Entity_MESH_unknown_b2_get, METH_O, NULL},
	 { "new_Dwg_Entity_MESH", _wrap_new_Dwg_Entity_MESH, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_MESH", _wrap_delete_Dwg_Entity_MESH, METH_O, NULL},
	 { "Dwg_Entity_MESH_swigregister", Dwg_Entity_MESH_swigregister, METH_O, NULL},
	 { "Dwg_Entity_MESH_swiginit", Dwg_Entity_MESH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_parent_set", _wrap_Dwg_Object_SUN_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_parent_get", _wrap_Dwg_Object_SUN_parent_get, METH_O, NULL},
	 { "Dwg_Object_SUN_class_version_set", _wrap_Dwg_Object_SUN_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_class_version_get", _wrap_Dwg_Object_SUN_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SUN_is_on_set", _wrap_Dwg_Object_SUN_is_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_is_on_get", _wrap_Dwg_Object_SUN_is_on_get, METH_O, NULL},
	 { "Dwg_Object_SUN_color_set", _wrap_Dwg_Object_SUN_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_color_get", _wrap_Dwg_Object_SUN_color_get, METH_O, NULL},
	 { "Dwg_Object_SUN_intensity_set", _wrap_Dwg_Object_SUN_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_intensity_get", _wrap_Dwg_Object_SUN_intensity_get, METH_O, NULL},
	 { "Dwg_Object_SUN_has_shadow_set", _wrap_Dwg_Object_SUN_has_shadow_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_has_shadow_get", _wrap_Dwg_Object_SUN_has_shadow_get, METH_O, NULL},
	 { "Dwg_Object_SUN_julian_day_set", _wrap_Dwg_Object_SUN_julian_day_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_julian_day_get", _wrap_Dwg_Object_SUN_julian_day_get, METH_O, NULL},
	 { "Dwg_Object_SUN_msecs_set", _wrap_Dwg_Object_SUN_msecs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_msecs_get", _wrap_Dwg_Object_SUN_msecs_get, METH_O, NULL},
	 { "Dwg_Object_SUN_is_dst_set", _wrap_Dwg_Object_SUN_is_dst_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_is_dst_get", _wrap_Dwg_Object_SUN_is_dst_get, METH_O, NULL},
	 { "Dwg_Object_SUN_shadow_type_set", _wrap_Dwg_Object_SUN_shadow_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_shadow_type_get", _wrap_Dwg_Object_SUN_shadow_type_get, METH_O, NULL},
	 { "Dwg_Object_SUN_shadow_mapsize_set", _wrap_Dwg_Object_SUN_shadow_mapsize_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_shadow_mapsize_get", _wrap_Dwg_Object_SUN_shadow_mapsize_get, METH_O, NULL},
	 { "Dwg_Object_SUN_shadow_softness_set", _wrap_Dwg_Object_SUN_shadow_softness_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUN_shadow_softness_get", _wrap_Dwg_Object_SUN_shadow_softness_get, METH_O, NULL},
	 { "new_Dwg_Object_SUN", _wrap_new_Dwg_Object_SUN, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SUN", _wrap_delete_Dwg_Object_SUN, METH_O, NULL},
	 { "Dwg_Object_SUN_swigregister", Dwg_Object_SUN_swigregister, METH_O, NULL},
	 { "Dwg_Object_SUN_swiginit", Dwg_Object_SUN_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SUNSTUDY_Dates_julian_day_set", _wrap_Dwg_SUNSTUDY_Dates_julian_day_set, METH_VARARGS, NULL},
	 { "Dwg_SUNSTUDY_Dates_julian_day_get", _wrap_Dwg_SUNSTUDY_Dates_julian_day_get, METH_O, NULL},
	 { "Dwg_SUNSTUDY_Dates_msecs_set", _wrap_Dwg_SUNSTUDY_Dates_msecs_set, METH_VARARGS, NULL},
	 { "Dwg_SUNSTUDY_Dates_msecs_get", _wrap_Dwg_SUNSTUDY_Dates_msecs_get, METH_O, NULL},
	 { "new_Dwg_SUNSTUDY_Dates", _wrap_new_Dwg_SUNSTUDY_Dates, METH_NOARGS, NULL},
	 { "delete_Dwg_SUNSTUDY_Dates", _wrap_delete_Dwg_SUNSTUDY_Dates, METH_O, NULL},
	 { "Dwg_SUNSTUDY_Dates_swigregister", Dwg_SUNSTUDY_Dates_swigregister, METH_O, NULL},
	 { "Dwg_SUNSTUDY_Dates_swiginit", Dwg_SUNSTUDY_Dates_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_parent_set", _wrap_Dwg_Object_SUNSTUDY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_parent_get", _wrap_Dwg_Object_SUNSTUDY_parent_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_class_version_set", _wrap_Dwg_Object_SUNSTUDY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_class_version_get", _wrap_Dwg_Object_SUNSTUDY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_setup_name_set", _wrap_Dwg_Object_SUNSTUDY_setup_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_setup_name_get", _wrap_Dwg_Object_SUNSTUDY_setup_name_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_description_set", _wrap_Dwg_Object_SUNSTUDY_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_description_get", _wrap_Dwg_Object_SUNSTUDY_description_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_output_type_set", _wrap_Dwg_Object_SUNSTUDY_output_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_output_type_get", _wrap_Dwg_Object_SUNSTUDY_output_type_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_sheet_set_name_set", _wrap_Dwg_Object_SUNSTUDY_sheet_set_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_sheet_set_name_get", _wrap_Dwg_Object_SUNSTUDY_sheet_set_name_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_use_subset_set", _wrap_Dwg_Object_SUNSTUDY_use_subset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_use_subset_get", _wrap_Dwg_Object_SUNSTUDY_use_subset_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_sheet_subset_name_set", _wrap_Dwg_Object_SUNSTUDY_sheet_subset_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_sheet_subset_name_get", _wrap_Dwg_Object_SUNSTUDY_sheet_subset_name_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_select_dates_from_calendar_set", _wrap_Dwg_Object_SUNSTUDY_select_dates_from_calendar_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_select_dates_from_calendar_get", _wrap_Dwg_Object_SUNSTUDY_select_dates_from_calendar_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_num_dates_set", _wrap_Dwg_Object_SUNSTUDY_num_dates_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_num_dates_get", _wrap_Dwg_Object_SUNSTUDY_num_dates_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_dates_set", _wrap_Dwg_Object_SUNSTUDY_dates_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_dates_get", _wrap_Dwg_Object_SUNSTUDY_dates_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_select_range_of_dates_set", _wrap_Dwg_Object_SUNSTUDY_select_range_of_dates_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_select_range_of_dates_get", _wrap_Dwg_Object_SUNSTUDY_select_range_of_dates_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_start_time_set", _wrap_Dwg_Object_SUNSTUDY_start_time_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_start_time_get", _wrap_Dwg_Object_SUNSTUDY_start_time_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_end_time_set", _wrap_Dwg_Object_SUNSTUDY_end_time_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_end_time_get", _wrap_Dwg_Object_SUNSTUDY_end_time_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_interval_set", _wrap_Dwg_Object_SUNSTUDY_interval_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_interval_get", _wrap_Dwg_Object_SUNSTUDY_interval_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_num_hours_set", _wrap_Dwg_Object_SUNSTUDY_num_hours_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_num_hours_get", _wrap_Dwg_Object_SUNSTUDY_num_hours_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_hours_set", _wrap_Dwg_Object_SUNSTUDY_hours_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_hours_get", _wrap_Dwg_Object_SUNSTUDY_hours_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_shade_plot_type_set", _wrap_Dwg_Object_SUNSTUDY_shade_plot_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_shade_plot_type_get", _wrap_Dwg_Object_SUNSTUDY_shade_plot_type_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_numvports_set", _wrap_Dwg_Object_SUNSTUDY_numvports_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_numvports_get", _wrap_Dwg_Object_SUNSTUDY_numvports_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_numrows_set", _wrap_Dwg_Object_SUNSTUDY_numrows_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_numrows_get", _wrap_Dwg_Object_SUNSTUDY_numrows_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_numcols_set", _wrap_Dwg_Object_SUNSTUDY_numcols_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_numcols_get", _wrap_Dwg_Object_SUNSTUDY_numcols_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_spacing_set", _wrap_Dwg_Object_SUNSTUDY_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_spacing_get", _wrap_Dwg_Object_SUNSTUDY_spacing_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_lock_viewports_set", _wrap_Dwg_Object_SUNSTUDY_lock_viewports_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_lock_viewports_get", _wrap_Dwg_Object_SUNSTUDY_lock_viewports_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_label_viewports_set", _wrap_Dwg_Object_SUNSTUDY_label_viewports_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_label_viewports_get", _wrap_Dwg_Object_SUNSTUDY_label_viewports_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_page_setup_wizard_set", _wrap_Dwg_Object_SUNSTUDY_page_setup_wizard_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_page_setup_wizard_get", _wrap_Dwg_Object_SUNSTUDY_page_setup_wizard_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_view_set", _wrap_Dwg_Object_SUNSTUDY_view_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_view_get", _wrap_Dwg_Object_SUNSTUDY_view_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_visualstyle_set", _wrap_Dwg_Object_SUNSTUDY_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_visualstyle_get", _wrap_Dwg_Object_SUNSTUDY_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_text_style_set", _wrap_Dwg_Object_SUNSTUDY_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SUNSTUDY_text_style_get", _wrap_Dwg_Object_SUNSTUDY_text_style_get, METH_O, NULL},
	 { "new_Dwg_Object_SUNSTUDY", _wrap_new_Dwg_Object_SUNSTUDY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SUNSTUDY", _wrap_delete_Dwg_Object_SUNSTUDY, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_swigregister", Dwg_Object_SUNSTUDY_swigregister, METH_O, NULL},
	 { "Dwg_Object_SUNSTUDY_swiginit", Dwg_Object_SUNSTUDY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_row_parent_set", _wrap_Dwg_DATATABLE_row_parent_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_row_parent_get", _wrap_Dwg_DATATABLE_row_parent_get, METH_O, NULL},
	 { "Dwg_DATATABLE_row_value_set", _wrap_Dwg_DATATABLE_row_value_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_row_value_get", _wrap_Dwg_DATATABLE_row_value_get, METH_O, NULL},
	 { "new_Dwg_DATATABLE_row", _wrap_new_Dwg_DATATABLE_row, METH_NOARGS, NULL},
	 { "delete_Dwg_DATATABLE_row", _wrap_delete_Dwg_DATATABLE_row, METH_O, NULL},
	 { "Dwg_DATATABLE_row_swigregister", Dwg_DATATABLE_row_swigregister, METH_O, NULL},
	 { "Dwg_DATATABLE_row_swiginit", Dwg_DATATABLE_row_swiginit, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_column_parent_set", _wrap_Dwg_DATATABLE_column_parent_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_column_parent_get", _wrap_Dwg_DATATABLE_column_parent_get, METH_O, NULL},
	 { "Dwg_DATATABLE_column_type_set", _wrap_Dwg_DATATABLE_column_type_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_column_type_get", _wrap_Dwg_DATATABLE_column_type_get, METH_O, NULL},
	 { "Dwg_DATATABLE_column_text_set", _wrap_Dwg_DATATABLE_column_text_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_column_text_get", _wrap_Dwg_DATATABLE_column_text_get, METH_O, NULL},
	 { "Dwg_DATATABLE_column_rows_set", _wrap_Dwg_DATATABLE_column_rows_set, METH_VARARGS, NULL},
	 { "Dwg_DATATABLE_column_rows_get", _wrap_Dwg_DATATABLE_column_rows_get, METH_O, NULL},
	 { "new_Dwg_DATATABLE_column", _wrap_new_Dwg_DATATABLE_column, METH_NOARGS, NULL},
	 { "delete_Dwg_DATATABLE_column", _wrap_delete_Dwg_DATATABLE_column, METH_O, NULL},
	 { "Dwg_DATATABLE_column_swigregister", Dwg_DATATABLE_column_swigregister, METH_O, NULL},
	 { "Dwg_DATATABLE_column_swiginit", Dwg_DATATABLE_column_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_parent_set", _wrap_Dwg_Object_DATATABLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_parent_get", _wrap_Dwg_Object_DATATABLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_flags_set", _wrap_Dwg_Object_DATATABLE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_flags_get", _wrap_Dwg_Object_DATATABLE_flags_get, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_num_cols_set", _wrap_Dwg_Object_DATATABLE_num_cols_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_num_cols_get", _wrap_Dwg_Object_DATATABLE_num_cols_get, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_num_rows_set", _wrap_Dwg_Object_DATATABLE_num_rows_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_num_rows_get", _wrap_Dwg_Object_DATATABLE_num_rows_get, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_table_name_set", _wrap_Dwg_Object_DATATABLE_table_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_table_name_get", _wrap_Dwg_Object_DATATABLE_table_name_get, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_cols_set", _wrap_Dwg_Object_DATATABLE_cols_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATATABLE_cols_get", _wrap_Dwg_Object_DATATABLE_cols_get, METH_O, NULL},
	 { "new_Dwg_Object_DATATABLE", _wrap_new_Dwg_Object_DATATABLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DATATABLE", _wrap_delete_Dwg_Object_DATATABLE, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_swigregister", Dwg_Object_DATATABLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_DATATABLE_swiginit", Dwg_Object_DATATABLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_DATALINK_customdata_parent_set", _wrap_Dwg_DATALINK_customdata_parent_set, METH_VARARGS, NULL},
	 { "Dwg_DATALINK_customdata_parent_get", _wrap_Dwg_DATALINK_customdata_parent_get, METH_O, NULL},
	 { "Dwg_DATALINK_customdata_target_set", _wrap_Dwg_DATALINK_customdata_target_set, METH_VARARGS, NULL},
	 { "Dwg_DATALINK_customdata_target_get", _wrap_Dwg_DATALINK_customdata_target_get, METH_O, NULL},
	 { "Dwg_DATALINK_customdata_text_set", _wrap_Dwg_DATALINK_customdata_text_set, METH_VARARGS, NULL},
	 { "Dwg_DATALINK_customdata_text_get", _wrap_Dwg_DATALINK_customdata_text_get, METH_O, NULL},
	 { "new_Dwg_DATALINK_customdata", _wrap_new_Dwg_DATALINK_customdata, METH_NOARGS, NULL},
	 { "delete_Dwg_DATALINK_customdata", _wrap_delete_Dwg_DATALINK_customdata, METH_O, NULL},
	 { "Dwg_DATALINK_customdata_swigregister", Dwg_DATALINK_customdata_swigregister, METH_O, NULL},
	 { "Dwg_DATALINK_customdata_swiginit", Dwg_DATALINK_customdata_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_parent_set", _wrap_Dwg_Object_DATALINK_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_parent_get", _wrap_Dwg_Object_DATALINK_parent_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_class_version_set", _wrap_Dwg_Object_DATALINK_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_class_version_get", _wrap_Dwg_Object_DATALINK_class_version_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_data_adapter_set", _wrap_Dwg_Object_DATALINK_data_adapter_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_data_adapter_get", _wrap_Dwg_Object_DATALINK_data_adapter_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_description_set", _wrap_Dwg_Object_DATALINK_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_description_get", _wrap_Dwg_Object_DATALINK_description_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_tooltip_set", _wrap_Dwg_Object_DATALINK_tooltip_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_tooltip_get", _wrap_Dwg_Object_DATALINK_tooltip_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_connection_string_set", _wrap_Dwg_Object_DATALINK_connection_string_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_connection_string_get", _wrap_Dwg_Object_DATALINK_connection_string_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_option_set", _wrap_Dwg_Object_DATALINK_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_option_get", _wrap_Dwg_Object_DATALINK_option_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_update_option_set", _wrap_Dwg_Object_DATALINK_update_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_update_option_get", _wrap_Dwg_Object_DATALINK_update_option_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_bl92_set", _wrap_Dwg_Object_DATALINK_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_bl92_get", _wrap_Dwg_Object_DATALINK_bl92_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_year_set", _wrap_Dwg_Object_DATALINK_year_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_year_get", _wrap_Dwg_Object_DATALINK_year_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_month_set", _wrap_Dwg_Object_DATALINK_month_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_month_get", _wrap_Dwg_Object_DATALINK_month_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_day_set", _wrap_Dwg_Object_DATALINK_day_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_day_get", _wrap_Dwg_Object_DATALINK_day_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_hour_set", _wrap_Dwg_Object_DATALINK_hour_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_hour_get", _wrap_Dwg_Object_DATALINK_hour_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_minute_set", _wrap_Dwg_Object_DATALINK_minute_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_minute_get", _wrap_Dwg_Object_DATALINK_minute_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_seconds_set", _wrap_Dwg_Object_DATALINK_seconds_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_seconds_get", _wrap_Dwg_Object_DATALINK_seconds_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_msec_set", _wrap_Dwg_Object_DATALINK_msec_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_msec_get", _wrap_Dwg_Object_DATALINK_msec_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_path_option_set", _wrap_Dwg_Object_DATALINK_path_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_path_option_get", _wrap_Dwg_Object_DATALINK_path_option_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_bl93_set", _wrap_Dwg_Object_DATALINK_bl93_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_bl93_get", _wrap_Dwg_Object_DATALINK_bl93_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_update_status_set", _wrap_Dwg_Object_DATALINK_update_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_update_status_get", _wrap_Dwg_Object_DATALINK_update_status_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_num_customdata_set", _wrap_Dwg_Object_DATALINK_num_customdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_num_customdata_get", _wrap_Dwg_Object_DATALINK_num_customdata_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_customdata_set", _wrap_Dwg_Object_DATALINK_customdata_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_customdata_get", _wrap_Dwg_Object_DATALINK_customdata_get, METH_O, NULL},
	 { "Dwg_Object_DATALINK_hardowner_set", _wrap_Dwg_Object_DATALINK_hardowner_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DATALINK_hardowner_get", _wrap_Dwg_Object_DATALINK_hardowner_get, METH_O, NULL},
	 { "new_Dwg_Object_DATALINK", _wrap_new_Dwg_Object_DATALINK, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DATALINK", _wrap_delete_Dwg_Object_DATALINK, METH_O, NULL},
	 { "Dwg_Object_DATALINK_swigregister", Dwg_Object_DATALINK_swigregister, METH_O, NULL},
	 { "Dwg_Object_DATALINK_swiginit", Dwg_Object_DATALINK_swiginit, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_parent_set", _wrap_Dwg_DIMASSOC_Ref_parent_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_parent_get", _wrap_Dwg_DIMASSOC_Ref_parent_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_classname_set", _wrap_Dwg_DIMASSOC_Ref_classname_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_classname_get", _wrap_Dwg_DIMASSOC_Ref_classname_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_type_set", _wrap_Dwg_DIMASSOC_Ref_osnap_type_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_type_get", _wrap_Dwg_DIMASSOC_Ref_osnap_type_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_dist_set", _wrap_Dwg_DIMASSOC_Ref_osnap_dist_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_dist_get", _wrap_Dwg_DIMASSOC_Ref_osnap_dist_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_pt_set", _wrap_Dwg_DIMASSOC_Ref_osnap_pt_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_osnap_pt_get", _wrap_Dwg_DIMASSOC_Ref_osnap_pt_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_num_xrefs_set", _wrap_Dwg_DIMASSOC_Ref_num_xrefs_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_num_xrefs_get", _wrap_Dwg_DIMASSOC_Ref_num_xrefs_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_xrefs_set", _wrap_Dwg_DIMASSOC_Ref_xrefs_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_xrefs_get", _wrap_Dwg_DIMASSOC_Ref_xrefs_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_main_subent_type_set", _wrap_Dwg_DIMASSOC_Ref_main_subent_type_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_main_subent_type_get", _wrap_Dwg_DIMASSOC_Ref_main_subent_type_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_main_gsmarker_set", _wrap_Dwg_DIMASSOC_Ref_main_gsmarker_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_main_gsmarker_get", _wrap_Dwg_DIMASSOC_Ref_main_gsmarker_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_num_xrefpaths_set", _wrap_Dwg_DIMASSOC_Ref_num_xrefpaths_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_num_xrefpaths_get", _wrap_Dwg_DIMASSOC_Ref_num_xrefpaths_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_xrefpaths_set", _wrap_Dwg_DIMASSOC_Ref_xrefpaths_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_xrefpaths_get", _wrap_Dwg_DIMASSOC_Ref_xrefpaths_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_has_lastpt_ref_set", _wrap_Dwg_DIMASSOC_Ref_has_lastpt_ref_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_has_lastpt_ref_get", _wrap_Dwg_DIMASSOC_Ref_has_lastpt_ref_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_lastpt_ref_set", _wrap_Dwg_DIMASSOC_Ref_lastpt_ref_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_lastpt_ref_get", _wrap_Dwg_DIMASSOC_Ref_lastpt_ref_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_num_intsectobj_set", _wrap_Dwg_DIMASSOC_Ref_num_intsectobj_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_num_intsectobj_get", _wrap_Dwg_DIMASSOC_Ref_num_intsectobj_get, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_intsectobj_set", _wrap_Dwg_DIMASSOC_Ref_intsectobj_set, METH_VARARGS, NULL},
	 { "Dwg_DIMASSOC_Ref_intsectobj_get", _wrap_Dwg_DIMASSOC_Ref_intsectobj_get, METH_O, NULL},
	 { "new_Dwg_DIMASSOC_Ref", _wrap_new_Dwg_DIMASSOC_Ref, METH_NOARGS, NULL},
	 { "delete_Dwg_DIMASSOC_Ref", _wrap_delete_Dwg_DIMASSOC_Ref, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_swigregister", Dwg_DIMASSOC_Ref_swigregister, METH_O, NULL},
	 { "Dwg_DIMASSOC_Ref_swiginit", Dwg_DIMASSOC_Ref_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_parent_set", _wrap_Dwg_Object_DIMASSOC_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_parent_get", _wrap_Dwg_Object_DIMASSOC_parent_get, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_dimensionobj_set", _wrap_Dwg_Object_DIMASSOC_dimensionobj_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_dimensionobj_get", _wrap_Dwg_Object_DIMASSOC_dimensionobj_get, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_associativity_set", _wrap_Dwg_Object_DIMASSOC_associativity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_associativity_get", _wrap_Dwg_Object_DIMASSOC_associativity_get, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_trans_space_flag_set", _wrap_Dwg_Object_DIMASSOC_trans_space_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_trans_space_flag_get", _wrap_Dwg_Object_DIMASSOC_trans_space_flag_get, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_rotated_type_set", _wrap_Dwg_Object_DIMASSOC_rotated_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_rotated_type_get", _wrap_Dwg_Object_DIMASSOC_rotated_type_get, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_ref_set", _wrap_Dwg_Object_DIMASSOC_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DIMASSOC_ref_get", _wrap_Dwg_Object_DIMASSOC_ref_get, METH_O, NULL},
	 { "new_Dwg_Object_DIMASSOC", _wrap_new_Dwg_Object_DIMASSOC, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DIMASSOC", _wrap_delete_Dwg_Object_DIMASSOC, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_swigregister", Dwg_Object_DIMASSOC_swigregister, METH_O, NULL},
	 { "Dwg_Object_DIMASSOC_swiginit", Dwg_Object_DIMASSOC_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ACTIONBODY_parent_set", _wrap_Dwg_ACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ACTIONBODY_parent_get", _wrap_Dwg_ACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_ACTIONBODY_evaluatorid_set", _wrap_Dwg_ACTIONBODY_evaluatorid_set, METH_VARARGS, NULL},
	 { "Dwg_ACTIONBODY_evaluatorid_get", _wrap_Dwg_ACTIONBODY_evaluatorid_get, METH_O, NULL},
	 { "Dwg_ACTIONBODY_expression_set", _wrap_Dwg_ACTIONBODY_expression_set, METH_VARARGS, NULL},
	 { "Dwg_ACTIONBODY_expression_get", _wrap_Dwg_ACTIONBODY_expression_get, METH_O, NULL},
	 { "Dwg_ACTIONBODY_value_set", _wrap_Dwg_ACTIONBODY_value_set, METH_VARARGS, NULL},
	 { "Dwg_ACTIONBODY_value_get", _wrap_Dwg_ACTIONBODY_value_get, METH_O, NULL},
	 { "new_Dwg_ACTIONBODY", _wrap_new_Dwg_ACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_ACTIONBODY", _wrap_delete_Dwg_ACTIONBODY, METH_O, NULL},
	 { "Dwg_ACTIONBODY_swigregister", Dwg_ACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_ACTIONBODY_swiginit", Dwg_ACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_EvalVariant_code_set", _wrap_Dwg_EvalVariant_code_set, METH_VARARGS, NULL},
	 { "Dwg_EvalVariant_code_get", _wrap_Dwg_EvalVariant_code_get, METH_O, NULL},
	 { "Dwg_EvalVariant_u_get", _wrap_Dwg_EvalVariant_u_get, METH_O, NULL},
	 { "new_Dwg_EvalVariant", _wrap_new_Dwg_EvalVariant, METH_NOARGS, NULL},
	 { "delete_Dwg_EvalVariant", _wrap_delete_Dwg_EvalVariant, METH_O, NULL},
	 { "Dwg_EvalVariant_swigregister", Dwg_EvalVariant_swigregister, METH_O, NULL},
	 { "Dwg_EvalVariant_swiginit", Dwg_EvalVariant_swiginit, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_bd_set", _wrap__dwg_EvalVariant_u_bd_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_bd_get", _wrap__dwg_EvalVariant_u_bd_get, METH_O, NULL},
	 { "_dwg_EvalVariant_u_bl_set", _wrap__dwg_EvalVariant_u_bl_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_bl_get", _wrap__dwg_EvalVariant_u_bl_get, METH_O, NULL},
	 { "_dwg_EvalVariant_u_bs_set", _wrap__dwg_EvalVariant_u_bs_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_bs_get", _wrap__dwg_EvalVariant_u_bs_get, METH_O, NULL},
	 { "_dwg_EvalVariant_u_rc_set", _wrap__dwg_EvalVariant_u_rc_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_rc_get", _wrap__dwg_EvalVariant_u_rc_get, METH_O, NULL},
	 { "_dwg_EvalVariant_u_text_set", _wrap__dwg_EvalVariant_u_text_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_text_get", _wrap__dwg_EvalVariant_u_text_get, METH_O, NULL},
	 { "_dwg_EvalVariant_u_handle_set", _wrap__dwg_EvalVariant_u_handle_set, METH_VARARGS, NULL},
	 { "_dwg_EvalVariant_u_handle_get", _wrap__dwg_EvalVariant_u_handle_get, METH_O, NULL},
	 { "new__dwg_EvalVariant_u", _wrap_new__dwg_EvalVariant_u, METH_NOARGS, NULL},
	 { "delete__dwg_EvalVariant_u", _wrap_delete__dwg_EvalVariant_u, METH_O, NULL},
	 { "_dwg_EvalVariant_u_swigregister", _dwg_EvalVariant_u_swigregister, METH_O, NULL},
	 { "_dwg_EvalVariant_u_swiginit", _dwg_EvalVariant_u_swiginit, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_vars_value_set", _wrap_Dwg_VALUEPARAM_vars_value_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_vars_value_get", _wrap_Dwg_VALUEPARAM_vars_value_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_vars_handle_set", _wrap_Dwg_VALUEPARAM_vars_handle_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_vars_handle_get", _wrap_Dwg_VALUEPARAM_vars_handle_get, METH_O, NULL},
	 { "new_Dwg_VALUEPARAM_vars", _wrap_new_Dwg_VALUEPARAM_vars, METH_NOARGS, NULL},
	 { "delete_Dwg_VALUEPARAM_vars", _wrap_delete_Dwg_VALUEPARAM_vars, METH_O, NULL},
	 { "Dwg_VALUEPARAM_vars_swigregister", Dwg_VALUEPARAM_vars_swigregister, METH_O, NULL},
	 { "Dwg_VALUEPARAM_vars_swiginit", Dwg_VALUEPARAM_vars_swiginit, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_parent_set", _wrap_Dwg_VALUEPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_parent_get", _wrap_Dwg_VALUEPARAM_parent_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_class_version_set", _wrap_Dwg_VALUEPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_class_version_get", _wrap_Dwg_VALUEPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_name_set", _wrap_Dwg_VALUEPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_name_get", _wrap_Dwg_VALUEPARAM_name_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_unit_type_set", _wrap_Dwg_VALUEPARAM_unit_type_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_unit_type_get", _wrap_Dwg_VALUEPARAM_unit_type_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_num_vars_set", _wrap_Dwg_VALUEPARAM_num_vars_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_num_vars_get", _wrap_Dwg_VALUEPARAM_num_vars_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_vars_set", _wrap_Dwg_VALUEPARAM_vars_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_vars_get", _wrap_Dwg_VALUEPARAM_vars_get, METH_O, NULL},
	 { "Dwg_VALUEPARAM_controlled_objdep_set", _wrap_Dwg_VALUEPARAM_controlled_objdep_set, METH_VARARGS, NULL},
	 { "Dwg_VALUEPARAM_controlled_objdep_get", _wrap_Dwg_VALUEPARAM_controlled_objdep_get, METH_O, NULL},
	 { "new_Dwg_VALUEPARAM", _wrap_new_Dwg_VALUEPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_VALUEPARAM", _wrap_delete_Dwg_VALUEPARAM, METH_O, NULL},
	 { "Dwg_VALUEPARAM_swigregister", Dwg_VALUEPARAM_swigregister, METH_O, NULL},
	 { "Dwg_VALUEPARAM_swiginit", Dwg_VALUEPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_parent_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_version_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_version_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_version_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_version_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_minor_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_minor_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_minor_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_deps_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_deps_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_deps_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_deps_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l4_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_l4_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l4_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l5_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_l5_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_l5_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_assocdep_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_num_values_get, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_values_set", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_values_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_values_get", _wrap_Dwg_ASSOCPARAMBASEDACTIONBODY_values_get, METH_O, NULL},
	 { "new_Dwg_ASSOCPARAMBASEDACTIONBODY", _wrap_new_Dwg_ASSOCPARAMBASEDACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_ASSOCPARAMBASEDACTIONBODY", _wrap_delete_Dwg_ASSOCPARAMBASEDACTIONBODY, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_swigregister", Dwg_ASSOCPARAMBASEDACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_ASSOCPARAMBASEDACTIONBODY_swiginit", Dwg_ASSOCPARAMBASEDACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTION_Deps_parent_set", _wrap_Dwg_ASSOCACTION_Deps_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTION_Deps_parent_get", _wrap_Dwg_ASSOCACTION_Deps_parent_get, METH_O, NULL},
	 { "Dwg_ASSOCACTION_Deps_is_owned_set", _wrap_Dwg_ASSOCACTION_Deps_is_owned_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTION_Deps_is_owned_get", _wrap_Dwg_ASSOCACTION_Deps_is_owned_get, METH_O, NULL},
	 { "Dwg_ASSOCACTION_Deps_dep_set", _wrap_Dwg_ASSOCACTION_Deps_dep_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTION_Deps_dep_get", _wrap_Dwg_ASSOCACTION_Deps_dep_get, METH_O, NULL},
	 { "new_Dwg_ASSOCACTION_Deps", _wrap_new_Dwg_ASSOCACTION_Deps, METH_NOARGS, NULL},
	 { "delete_Dwg_ASSOCACTION_Deps", _wrap_delete_Dwg_ASSOCACTION_Deps, METH_O, NULL},
	 { "Dwg_ASSOCACTION_Deps_swigregister", Dwg_ASSOCACTION_Deps_swigregister, METH_O, NULL},
	 { "Dwg_ASSOCACTION_Deps_swiginit", Dwg_ASSOCACTION_Deps_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_parent_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_parent_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_class_version_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_class_version_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_status_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_status_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_read_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_read_dep_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_read_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_write_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_write_dep_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_write_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_attached_to_object_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_is_delegating_to_owning_action_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_order_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_order_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_order_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_order_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_dep_on_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_dep_on_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_dep_on_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_dep_on_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_has_name_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_has_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_has_name_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_has_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_name_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_name_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_depbodyid_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_depbodyid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_depbodyid_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_depbodyid_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_readdep_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_readdep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_readdep_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_readdep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_dep_body_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_dep_body_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_dep_body_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_dep_body_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_node_set", _wrap_Dwg_Object_ASSOCDEPENDENCY_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_node_get", _wrap_Dwg_Object_ASSOCDEPENDENCY_node_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCDEPENDENCY", _wrap_new_Dwg_Object_ASSOCDEPENDENCY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCDEPENDENCY", _wrap_delete_Dwg_Object_ASSOCDEPENDENCY, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_swigregister", Dwg_Object_ASSOCDEPENDENCY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCDEPENDENCY_swiginit", Dwg_Object_ASSOCDEPENDENCY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set", _wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_parent_get", _wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set", _wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_get", _wrap_Dwg_Object_ASSOCVALUEDEPENDENCY_assocdep_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCVALUEDEPENDENCY", _wrap_new_Dwg_Object_ASSOCVALUEDEPENDENCY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCVALUEDEPENDENCY", _wrap_delete_Dwg_Object_ASSOCVALUEDEPENDENCY, METH_O, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_swigregister", Dwg_Object_ASSOCVALUEDEPENDENCY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCVALUEDEPENDENCY_swiginit", Dwg_Object_ASSOCVALUEDEPENDENCY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_parent_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_assocdep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_enabled_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_classname_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_classname_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_classname_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_get", _wrap_Dwg_Object_ASSOCGEOMDEPENDENCY_dependent_on_compound_object_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCGEOMDEPENDENCY", _wrap_new_Dwg_Object_ASSOCGEOMDEPENDENCY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCGEOMDEPENDENCY", _wrap_delete_Dwg_Object_ASSOCGEOMDEPENDENCY, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_swigregister", Dwg_Object_ASSOCGEOMDEPENDENCY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCGEOMDEPENDENCY_swiginit", Dwg_Object_ASSOCGEOMDEPENDENCY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_parent_set", _wrap_Dwg_Object_ASSOCACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_parent_get", _wrap_Dwg_Object_ASSOCACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_class_version_set", _wrap_Dwg_Object_ASSOCACTION_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_class_version_get", _wrap_Dwg_Object_ASSOCACTION_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_geometry_status_set", _wrap_Dwg_Object_ASSOCACTION_geometry_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_geometry_status_get", _wrap_Dwg_Object_ASSOCACTION_geometry_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_owningnetwork_set", _wrap_Dwg_Object_ASSOCACTION_owningnetwork_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_owningnetwork_get", _wrap_Dwg_Object_ASSOCACTION_owningnetwork_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_actionbody_set", _wrap_Dwg_Object_ASSOCACTION_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_actionbody_get", _wrap_Dwg_Object_ASSOCACTION_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_action_index_set", _wrap_Dwg_Object_ASSOCACTION_action_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_action_index_get", _wrap_Dwg_Object_ASSOCACTION_action_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_max_assoc_dep_index_set", _wrap_Dwg_Object_ASSOCACTION_max_assoc_dep_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_max_assoc_dep_index_get", _wrap_Dwg_Object_ASSOCACTION_max_assoc_dep_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_num_deps_set", _wrap_Dwg_Object_ASSOCACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_num_deps_get", _wrap_Dwg_Object_ASSOCACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_deps_set", _wrap_Dwg_Object_ASSOCACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_deps_get", _wrap_Dwg_Object_ASSOCACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_num_owned_params_set", _wrap_Dwg_Object_ASSOCACTION_num_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_num_owned_params_get", _wrap_Dwg_Object_ASSOCACTION_num_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_owned_params_set", _wrap_Dwg_Object_ASSOCACTION_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_owned_params_get", _wrap_Dwg_Object_ASSOCACTION_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_num_values_set", _wrap_Dwg_Object_ASSOCACTION_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_num_values_get", _wrap_Dwg_Object_ASSOCACTION_num_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_values_set", _wrap_Dwg_Object_ASSOCACTION_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTION_values_get", _wrap_Dwg_Object_ASSOCACTION_values_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCACTION", _wrap_new_Dwg_Object_ASSOCACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCACTION", _wrap_delete_Dwg_Object_ASSOCACTION, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_swigregister", Dwg_Object_ASSOCACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTION_swiginit", Dwg_Object_ASSOCACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_parent_set", _wrap_Dwg_Object_ASSOCNETWORK_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_parent_get", _wrap_Dwg_Object_ASSOCNETWORK_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_class_version_set", _wrap_Dwg_Object_ASSOCNETWORK_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_class_version_get", _wrap_Dwg_Object_ASSOCNETWORK_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_geometry_status_set", _wrap_Dwg_Object_ASSOCNETWORK_geometry_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_geometry_status_get", _wrap_Dwg_Object_ASSOCNETWORK_geometry_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owningnetwork_set", _wrap_Dwg_Object_ASSOCNETWORK_owningnetwork_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owningnetwork_get", _wrap_Dwg_Object_ASSOCNETWORK_owningnetwork_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_actionbody_set", _wrap_Dwg_Object_ASSOCNETWORK_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_actionbody_get", _wrap_Dwg_Object_ASSOCNETWORK_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_action_index_set", _wrap_Dwg_Object_ASSOCNETWORK_action_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_action_index_get", _wrap_Dwg_Object_ASSOCNETWORK_action_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set", _wrap_Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_get", _wrap_Dwg_Object_ASSOCNETWORK_max_assoc_dep_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_deps_set", _wrap_Dwg_Object_ASSOCNETWORK_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_deps_get", _wrap_Dwg_Object_ASSOCNETWORK_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_deps_set", _wrap_Dwg_Object_ASSOCNETWORK_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_deps_get", _wrap_Dwg_Object_ASSOCNETWORK_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_owned_params_set", _wrap_Dwg_Object_ASSOCNETWORK_num_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_owned_params_get", _wrap_Dwg_Object_ASSOCNETWORK_num_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owned_params_set", _wrap_Dwg_Object_ASSOCNETWORK_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owned_params_get", _wrap_Dwg_Object_ASSOCNETWORK_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_values_set", _wrap_Dwg_Object_ASSOCNETWORK_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_values_get", _wrap_Dwg_Object_ASSOCNETWORK_num_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_values_set", _wrap_Dwg_Object_ASSOCNETWORK_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_values_get", _wrap_Dwg_Object_ASSOCNETWORK_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_network_version_set", _wrap_Dwg_Object_ASSOCNETWORK_network_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_network_version_get", _wrap_Dwg_Object_ASSOCNETWORK_network_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_network_action_index_set", _wrap_Dwg_Object_ASSOCNETWORK_network_action_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_network_action_index_get", _wrap_Dwg_Object_ASSOCNETWORK_network_action_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_actions_set", _wrap_Dwg_Object_ASSOCNETWORK_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_actions_get", _wrap_Dwg_Object_ASSOCNETWORK_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_actions_set", _wrap_Dwg_Object_ASSOCNETWORK_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_actions_get", _wrap_Dwg_Object_ASSOCNETWORK_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_owned_actions_set", _wrap_Dwg_Object_ASSOCNETWORK_num_owned_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_num_owned_actions_get", _wrap_Dwg_Object_ASSOCNETWORK_num_owned_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owned_actions_set", _wrap_Dwg_Object_ASSOCNETWORK_owned_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORK_owned_actions_get", _wrap_Dwg_Object_ASSOCNETWORK_owned_actions_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCNETWORK", _wrap_new_Dwg_Object_ASSOCNETWORK, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCNETWORK", _wrap_delete_Dwg_Object_ASSOCNETWORK, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_swigregister", Dwg_Object_ASSOCNETWORK_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORK_swiginit", Dwg_Object_ASSOCNETWORK_swiginit, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_parent_set", _wrap_Dwg_CONSTRAINTGROUPNODE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_parent_get", _wrap_Dwg_CONSTRAINTGROUPNODE_parent_get, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_nodeid_set", _wrap_Dwg_CONSTRAINTGROUPNODE_nodeid_set, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_nodeid_get", _wrap_Dwg_CONSTRAINTGROUPNODE_nodeid_get, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_status_set", _wrap_Dwg_CONSTRAINTGROUPNODE_status_set, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_status_get", _wrap_Dwg_CONSTRAINTGROUPNODE_status_get, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_num_connections_set", _wrap_Dwg_CONSTRAINTGROUPNODE_num_connections_set, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_num_connections_get", _wrap_Dwg_CONSTRAINTGROUPNODE_num_connections_get, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_connections_set", _wrap_Dwg_CONSTRAINTGROUPNODE_connections_set, METH_VARARGS, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_connections_get", _wrap_Dwg_CONSTRAINTGROUPNODE_connections_get, METH_O, NULL},
	 { "new_Dwg_CONSTRAINTGROUPNODE", _wrap_new_Dwg_CONSTRAINTGROUPNODE, METH_NOARGS, NULL},
	 { "delete_Dwg_CONSTRAINTGROUPNODE", _wrap_delete_Dwg_CONSTRAINTGROUPNODE, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_swigregister", Dwg_CONSTRAINTGROUPNODE_swigregister, METH_O, NULL},
	 { "Dwg_CONSTRAINTGROUPNODE_swiginit", Dwg_CONSTRAINTGROUPNODE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_geometry_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owningnetwork_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_action_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_max_assoc_dep_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_b1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_workplane_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_h1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_num_nodes_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_get", _wrap_Dwg_Object_ASSOC2DCONSTRAINTGROUP_nodes_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOC2DCONSTRAINTGROUP", _wrap_new_Dwg_Object_ASSOC2DCONSTRAINTGROUP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOC2DCONSTRAINTGROUP", _wrap_delete_Dwg_Object_ASSOC2DCONSTRAINTGROUP, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_swigregister", Dwg_Object_ASSOC2DCONSTRAINTGROUP_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOC2DCONSTRAINTGROUP_swiginit", Dwg_Object_ASSOC2DCONSTRAINTGROUP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_parent_set", _wrap_Dwg_Object_ASSOCVARIABLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_parent_get", _wrap_Dwg_Object_ASSOCVARIABLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_av_class_version_set", _wrap_Dwg_Object_ASSOCVARIABLE_av_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_av_class_version_get", _wrap_Dwg_Object_ASSOCVARIABLE_av_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_class_version_set", _wrap_Dwg_Object_ASSOCVARIABLE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_class_version_get", _wrap_Dwg_Object_ASSOCVARIABLE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_geometry_status_set", _wrap_Dwg_Object_ASSOCVARIABLE_geometry_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_geometry_status_get", _wrap_Dwg_Object_ASSOCVARIABLE_geometry_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_owningnetwork_set", _wrap_Dwg_Object_ASSOCVARIABLE_owningnetwork_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_owningnetwork_get", _wrap_Dwg_Object_ASSOCVARIABLE_owningnetwork_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_actionbody_set", _wrap_Dwg_Object_ASSOCVARIABLE_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_actionbody_get", _wrap_Dwg_Object_ASSOCVARIABLE_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_action_index_set", _wrap_Dwg_Object_ASSOCVARIABLE_action_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_action_index_get", _wrap_Dwg_Object_ASSOCVARIABLE_action_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set", _wrap_Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_get", _wrap_Dwg_Object_ASSOCVARIABLE_max_assoc_dep_index_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_deps_set", _wrap_Dwg_Object_ASSOCVARIABLE_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_deps_get", _wrap_Dwg_Object_ASSOCVARIABLE_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_deps_set", _wrap_Dwg_Object_ASSOCVARIABLE_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_deps_get", _wrap_Dwg_Object_ASSOCVARIABLE_deps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_owned_params_set", _wrap_Dwg_Object_ASSOCVARIABLE_num_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_owned_params_get", _wrap_Dwg_Object_ASSOCVARIABLE_num_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_owned_params_set", _wrap_Dwg_Object_ASSOCVARIABLE_owned_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_owned_params_get", _wrap_Dwg_Object_ASSOCVARIABLE_owned_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_values_set", _wrap_Dwg_Object_ASSOCVARIABLE_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_num_values_get", _wrap_Dwg_Object_ASSOCVARIABLE_num_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_values_set", _wrap_Dwg_Object_ASSOCVARIABLE_values_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_values_get", _wrap_Dwg_Object_ASSOCVARIABLE_values_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_name_set", _wrap_Dwg_Object_ASSOCVARIABLE_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_name_get", _wrap_Dwg_Object_ASSOCVARIABLE_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_t58_set", _wrap_Dwg_Object_ASSOCVARIABLE_t58_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_t58_get", _wrap_Dwg_Object_ASSOCVARIABLE_t58_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_evaluator_set", _wrap_Dwg_Object_ASSOCVARIABLE_evaluator_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_evaluator_get", _wrap_Dwg_Object_ASSOCVARIABLE_evaluator_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_desc_set", _wrap_Dwg_Object_ASSOCVARIABLE_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_desc_get", _wrap_Dwg_Object_ASSOCVARIABLE_desc_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_value_set", _wrap_Dwg_Object_ASSOCVARIABLE_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_value_get", _wrap_Dwg_Object_ASSOCVARIABLE_value_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_has_t78_set", _wrap_Dwg_Object_ASSOCVARIABLE_has_t78_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_has_t78_get", _wrap_Dwg_Object_ASSOCVARIABLE_has_t78_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_t78_set", _wrap_Dwg_Object_ASSOCVARIABLE_t78_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_t78_get", _wrap_Dwg_Object_ASSOCVARIABLE_t78_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_b290_set", _wrap_Dwg_Object_ASSOCVARIABLE_b290_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_b290_get", _wrap_Dwg_Object_ASSOCVARIABLE_b290_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCVARIABLE", _wrap_new_Dwg_Object_ASSOCVARIABLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCVARIABLE", _wrap_delete_Dwg_Object_ASSOCVARIABLE, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_swigregister", Dwg_Object_ASSOCVARIABLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCVARIABLE_swiginit", Dwg_Object_ASSOCVARIABLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_parent_set", _wrap_Dwg_EVAL_Node_parent_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_parent_get", _wrap_Dwg_EVAL_Node_parent_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_id_set", _wrap_Dwg_EVAL_Node_id_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_id_get", _wrap_Dwg_EVAL_Node_id_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_edge_flags_set", _wrap_Dwg_EVAL_Node_edge_flags_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_edge_flags_get", _wrap_Dwg_EVAL_Node_edge_flags_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_nextid_set", _wrap_Dwg_EVAL_Node_nextid_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_nextid_get", _wrap_Dwg_EVAL_Node_nextid_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_evalexpr_set", _wrap_Dwg_EVAL_Node_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_evalexpr_get", _wrap_Dwg_EVAL_Node_evalexpr_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_node_set", _wrap_Dwg_EVAL_Node_node_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_node_get", _wrap_Dwg_EVAL_Node_node_get, METH_O, NULL},
	 { "Dwg_EVAL_Node_active_cycles_set", _wrap_Dwg_EVAL_Node_active_cycles_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Node_active_cycles_get", _wrap_Dwg_EVAL_Node_active_cycles_get, METH_O, NULL},
	 { "new_Dwg_EVAL_Node", _wrap_new_Dwg_EVAL_Node, METH_NOARGS, NULL},
	 { "delete_Dwg_EVAL_Node", _wrap_delete_Dwg_EVAL_Node, METH_O, NULL},
	 { "Dwg_EVAL_Node_swigregister", Dwg_EVAL_Node_swigregister, METH_O, NULL},
	 { "Dwg_EVAL_Node_swiginit", Dwg_EVAL_Node_swiginit, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_parent_set", _wrap_Dwg_EVAL_Edge_parent_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_parent_get", _wrap_Dwg_EVAL_Edge_parent_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_id_set", _wrap_Dwg_EVAL_Edge_id_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_id_get", _wrap_Dwg_EVAL_Edge_id_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_nextid_set", _wrap_Dwg_EVAL_Edge_nextid_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_nextid_get", _wrap_Dwg_EVAL_Edge_nextid_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_e1_set", _wrap_Dwg_EVAL_Edge_e1_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_e1_get", _wrap_Dwg_EVAL_Edge_e1_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_e2_set", _wrap_Dwg_EVAL_Edge_e2_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_e2_get", _wrap_Dwg_EVAL_Edge_e2_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_e3_set", _wrap_Dwg_EVAL_Edge_e3_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_e3_get", _wrap_Dwg_EVAL_Edge_e3_get, METH_O, NULL},
	 { "Dwg_EVAL_Edge_out_edge_set", _wrap_Dwg_EVAL_Edge_out_edge_set, METH_VARARGS, NULL},
	 { "Dwg_EVAL_Edge_out_edge_get", _wrap_Dwg_EVAL_Edge_out_edge_get, METH_O, NULL},
	 { "new_Dwg_EVAL_Edge", _wrap_new_Dwg_EVAL_Edge, METH_NOARGS, NULL},
	 { "delete_Dwg_EVAL_Edge", _wrap_delete_Dwg_EVAL_Edge, METH_O, NULL},
	 { "Dwg_EVAL_Edge_swigregister", Dwg_EVAL_Edge_swigregister, METH_O, NULL},
	 { "Dwg_EVAL_Edge_swiginit", Dwg_EVAL_Edge_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_parent_set", _wrap_Dwg_Object_EVALUATION_GRAPH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_parent_get", _wrap_Dwg_Object_EVALUATION_GRAPH_parent_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_major_set", _wrap_Dwg_Object_EVALUATION_GRAPH_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_major_get", _wrap_Dwg_Object_EVALUATION_GRAPH_major_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_minor_set", _wrap_Dwg_Object_EVALUATION_GRAPH_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_minor_get", _wrap_Dwg_Object_EVALUATION_GRAPH_minor_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_first_nodeid_set", _wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_first_nodeid_get", _wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set", _wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_get", _wrap_Dwg_Object_EVALUATION_GRAPH_first_nodeid_copy_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_num_nodes_set", _wrap_Dwg_Object_EVALUATION_GRAPH_num_nodes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_num_nodes_get", _wrap_Dwg_Object_EVALUATION_GRAPH_num_nodes_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_nodes_set", _wrap_Dwg_Object_EVALUATION_GRAPH_nodes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_nodes_get", _wrap_Dwg_Object_EVALUATION_GRAPH_nodes_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_has_graph_set", _wrap_Dwg_Object_EVALUATION_GRAPH_has_graph_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_has_graph_get", _wrap_Dwg_Object_EVALUATION_GRAPH_has_graph_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_num_edges_set", _wrap_Dwg_Object_EVALUATION_GRAPH_num_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_num_edges_get", _wrap_Dwg_Object_EVALUATION_GRAPH_num_edges_get, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_edges_set", _wrap_Dwg_Object_EVALUATION_GRAPH_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_edges_get", _wrap_Dwg_Object_EVALUATION_GRAPH_edges_get, METH_O, NULL},
	 { "new_Dwg_Object_EVALUATION_GRAPH", _wrap_new_Dwg_Object_EVALUATION_GRAPH, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_EVALUATION_GRAPH", _wrap_delete_Dwg_Object_EVALUATION_GRAPH, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_swigregister", Dwg_Object_EVALUATION_GRAPH_swigregister, METH_O, NULL},
	 { "Dwg_Object_EVALUATION_GRAPH_swiginit", Dwg_Object_EVALUATION_GRAPH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_get", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_parent_get, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_get", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_flag_get, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_get", _wrap_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_block_get, METH_O, NULL},
	 { "new_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER", _wrap_new_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER", _wrap_delete_Dwg_Object_DYNAMICBLOCKPURGEPREVENTER, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swigregister", Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swigregister, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swiginit", Dwg_Object_DYNAMICBLOCKPURGEPREVENTER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_parent_set", _wrap_Dwg_Object_PERSUBENTMGR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_parent_get", _wrap_Dwg_Object_PERSUBENTMGR_parent_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_class_version_set", _wrap_Dwg_Object_PERSUBENTMGR_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_class_version_get", _wrap_Dwg_Object_PERSUBENTMGR_class_version_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_unknown_0_set", _wrap_Dwg_Object_PERSUBENTMGR_unknown_0_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_unknown_0_get", _wrap_Dwg_Object_PERSUBENTMGR_unknown_0_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_unknown_2_set", _wrap_Dwg_Object_PERSUBENTMGR_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_unknown_2_get", _wrap_Dwg_Object_PERSUBENTMGR_unknown_2_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_numassocsteps_set", _wrap_Dwg_Object_PERSUBENTMGR_numassocsteps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_numassocsteps_get", _wrap_Dwg_Object_PERSUBENTMGR_numassocsteps_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_numassocsubents_set", _wrap_Dwg_Object_PERSUBENTMGR_numassocsubents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_numassocsubents_get", _wrap_Dwg_Object_PERSUBENTMGR_numassocsubents_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_num_steps_set", _wrap_Dwg_Object_PERSUBENTMGR_num_steps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_num_steps_get", _wrap_Dwg_Object_PERSUBENTMGR_num_steps_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_steps_set", _wrap_Dwg_Object_PERSUBENTMGR_steps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_steps_get", _wrap_Dwg_Object_PERSUBENTMGR_steps_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_num_subents_set", _wrap_Dwg_Object_PERSUBENTMGR_num_subents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_num_subents_get", _wrap_Dwg_Object_PERSUBENTMGR_num_subents_get, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_subents_set", _wrap_Dwg_Object_PERSUBENTMGR_subents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PERSUBENTMGR_subents_get", _wrap_Dwg_Object_PERSUBENTMGR_subents_get, METH_O, NULL},
	 { "new_Dwg_Object_PERSUBENTMGR", _wrap_new_Dwg_Object_PERSUBENTMGR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_PERSUBENTMGR", _wrap_delete_Dwg_Object_PERSUBENTMGR, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_swigregister", Dwg_Object_PERSUBENTMGR_swigregister, METH_O, NULL},
	 { "Dwg_Object_PERSUBENTMGR_swiginit", Dwg_Object_PERSUBENTMGR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_3_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_0_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_steps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_num_subents_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_steps_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_subents_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl6a_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7a_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl7_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl8_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl9_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl10_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl11_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl12_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl13_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl14_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl15_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl16_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl17_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl18_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl19_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl20_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl21_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl22_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl23_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl24_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl25_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl26_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl27_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl28_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl29_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl30_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl31_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl32_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl33_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl34_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl35_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_bl36_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_get", _wrap_Dwg_Object_ASSOCPERSSUBENTMANAGER_unknown_b37_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCPERSSUBENTMANAGER", _wrap_new_Dwg_Object_ASSOCPERSSUBENTMANAGER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCPERSSUBENTMANAGER", _wrap_delete_Dwg_Object_ASSOCPERSSUBENTMANAGER, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_swigregister", Dwg_Object_ASSOCPERSSUBENTMANAGER_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCPERSSUBENTMANAGER_swiginit", Dwg_Object_ASSOCPERSSUBENTMANAGER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCACTIONPARAM_name_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCACTIONPARAM", _wrap_new_Dwg_Object_ASSOCACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_swigregister", Dwg_Object_ASSOCACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCACTIONPARAM_swiginit", Dwg_Object_ASSOCACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bs1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_num_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_has_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_id_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_bl2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_h330_3_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_osnap_mode_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_get", _wrap_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_param_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM", _wrap_new_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swigregister", Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swiginit", Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bs1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_num_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_has_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_id_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_bl2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_get", _wrap_Dwg_Object_ASSOCPOINTREFACTIONPARAM_h330_3_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCPOINTREFACTIONPARAM", _wrap_new_Dwg_Object_ASSOCPOINTREFACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCPOINTREFACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCPOINTREFACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_swigregister", Dwg_Object_ASSOCPOINTREFACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCPOINTREFACTIONPARAM_swiginit", Dwg_Object_ASSOCPOINTREFACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_asdap_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_unknown_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_version_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_blocks_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_block_size_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_sab_size_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_data_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_present_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_point_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_point_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isolines_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_isoline_present_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_wires_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_wires_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_silhouettes_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_num_materials_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_materials_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_guid_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_major_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_end_marker_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_history_id_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_get", _wrap_Dwg_Object_ASSOCASMBODYACTIONPARAM_acis_empty_bit_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCASMBODYACTIONPARAM", _wrap_new_Dwg_Object_ASSOCASMBODYACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCASMBODYACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCASMBODYACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_swigregister", Dwg_Object_ASSOCASMBODYACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCASMBODYACTIONPARAM_swiginit", Dwg_Object_ASSOCASMBODYACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bs1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_num_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_has_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_id_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_bl2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_get", _wrap_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_h330_3_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM", _wrap_new_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCCOMPOUNDACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swigregister", Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swiginit", Dwg_Object_ASSOCCOMPOUNDACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_asdap_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCOBJECTACTIONPARAM_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCOBJECTACTIONPARAM", _wrap_new_Dwg_Object_ASSOCOBJECTACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCOBJECTACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCOBJECTACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_swigregister", Dwg_Object_ASSOCOBJECTACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCOBJECTACTIONPARAM_swiginit", Dwg_Object_ASSOCOBJECTACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_asdap_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_dep_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_param_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_param_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_has_action_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_action_type_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_subent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_subent_get", _wrap_Dwg_Object_ASSOCEDGEACTIONPARAM_subent_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCEDGEACTIONPARAM", _wrap_new_Dwg_Object_ASSOCEDGEACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCEDGEACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCEDGEACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_swigregister", Dwg_Object_ASSOCEDGEACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEACTIONPARAM_swiginit", Dwg_Object_ASSOCEDGEACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_asdap_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_dep_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_dep_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_index_set", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_index_get", _wrap_Dwg_Object_ASSOCFACEACTIONPARAM_index_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCFACEACTIONPARAM", _wrap_new_Dwg_Object_ASSOCFACEACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCFACEACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCFACEACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_swigregister", Dwg_Object_ASSOCFACEACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCFACEACTIONPARAM_swiginit", Dwg_Object_ASSOCFACEACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bs1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_bs1_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bs1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_num_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_num_params_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_num_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_params_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_params_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_params_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_params_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_has_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_status_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_id_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_id_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_param_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_child_param_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_child_param_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bl2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_bl2_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_bl2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_h330_3_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_version_set", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_version_get", _wrap_Dwg_Object_ASSOCPATHACTIONPARAM_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCPATHACTIONPARAM", _wrap_new_Dwg_Object_ASSOCPATHACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCPATHACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCPATHACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_swigregister", Dwg_Object_ASSOCPATHACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATHACTIONPARAM_swiginit", Dwg_Object_ASSOCPATHACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_is_r2013_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_name_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_asdap_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_get", _wrap_Dwg_Object_ASSOCVERTEXACTIONPARAM_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCVERTEXACTIONPARAM", _wrap_new_Dwg_Object_ASSOCVERTEXACTIONPARAM, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCVERTEXACTIONPARAM", _wrap_delete_Dwg_Object_ASSOCVERTEXACTIONPARAM, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_swigregister", Dwg_Object_ASSOCVERTEXACTIONPARAM_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCVERTEXACTIONPARAM_swiginit", Dwg_Object_ASSOCVERTEXACTIONPARAM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_parent_set", _wrap_Dwg_ASSOCARRAYITEM_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_parent_get", _wrap_Dwg_ASSOCARRAYITEM_parent_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_class_version_set", _wrap_Dwg_ASSOCARRAYITEM_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_class_version_get", _wrap_Dwg_ASSOCARRAYITEM_class_version_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_itemloc_set", _wrap_Dwg_ASSOCARRAYITEM_itemloc_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_itemloc_get", _wrap_Dwg_ASSOCARRAYITEM_itemloc_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_flags_set", _wrap_Dwg_ASSOCARRAYITEM_flags_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_flags_get", _wrap_Dwg_ASSOCARRAYITEM_flags_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_is_default_transmatrix_set", _wrap_Dwg_ASSOCARRAYITEM_is_default_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_is_default_transmatrix_get", _wrap_Dwg_ASSOCARRAYITEM_is_default_transmatrix_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_x_dir_set", _wrap_Dwg_ASSOCARRAYITEM_x_dir_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_x_dir_get", _wrap_Dwg_ASSOCARRAYITEM_x_dir_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_transmatrix_set", _wrap_Dwg_ASSOCARRAYITEM_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_transmatrix_get", _wrap_Dwg_ASSOCARRAYITEM_transmatrix_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_rel_transform_set", _wrap_Dwg_ASSOCARRAYITEM_rel_transform_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_rel_transform_get", _wrap_Dwg_ASSOCARRAYITEM_rel_transform_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_has_h1_set", _wrap_Dwg_ASSOCARRAYITEM_has_h1_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_has_h1_get", _wrap_Dwg_ASSOCARRAYITEM_has_h1_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_h1_set", _wrap_Dwg_ASSOCARRAYITEM_h1_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_h1_get", _wrap_Dwg_ASSOCARRAYITEM_h1_get, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_h2_set", _wrap_Dwg_ASSOCARRAYITEM_h2_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCARRAYITEM_h2_get", _wrap_Dwg_ASSOCARRAYITEM_h2_get, METH_O, NULL},
	 { "new_Dwg_ASSOCARRAYITEM", _wrap_new_Dwg_ASSOCARRAYITEM, METH_NOARGS, NULL},
	 { "delete_Dwg_ASSOCARRAYITEM", _wrap_delete_Dwg_ASSOCARRAYITEM, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_swigregister", Dwg_ASSOCARRAYITEM_swigregister, METH_O, NULL},
	 { "Dwg_ASSOCARRAYITEM_swiginit", Dwg_ASSOCARRAYITEM_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_parent_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_parent_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_aap_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_num_items_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_num_items_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_num_items_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_classname_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_classname_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_classname_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_classname_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_items_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_items_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_items_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_items_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numitems_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numitems_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numitems_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numrows_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numrows_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numrows_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_get", _wrap_Dwg_Object_ASSOCARRAYPARAMETERS_numlevels_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCARRAYPARAMETERS", _wrap_new_Dwg_Object_ASSOCARRAYPARAMETERS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCARRAYPARAMETERS", _wrap_delete_Dwg_Object_ASSOCARRAYPARAMETERS, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_swigregister", Dwg_Object_ASSOCARRAYPARAMETERS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYPARAMETERS_swiginit", Dwg_Object_ASSOCARRAYPARAMETERS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_get", _wrap_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_entity_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY", _wrap_new_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swigregister", Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swiginit", Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_parent_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_parent_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_version_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_version_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_version_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_version_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_assoc_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_l2_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_l2_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_l2_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_l2_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_is_semi_ovr_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_grip_status_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_grip_status_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_grip_status_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_grip_status_get, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_assocdep_set", _wrap_Dwg_ASSOCSURFACEACTIONBODY_assocdep_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_assocdep_get", _wrap_Dwg_ASSOCSURFACEACTIONBODY_assocdep_get, METH_O, NULL},
	 { "new_Dwg_ASSOCSURFACEACTIONBODY", _wrap_new_Dwg_ASSOCSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_ASSOCSURFACEACTIONBODY", _wrap_delete_Dwg_ASSOCSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_swigregister", Dwg_ASSOCSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_ASSOCSURFACEACTIONBODY_swiginit", Dwg_ASSOCSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_get", _wrap_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_option_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCPLANESURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCPLANESURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCPLANESURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCPLANESURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCPLANESURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCPLANESURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_get", _wrap_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_b1_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY", _wrap_new_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY", _wrap_delete_Dwg_Object_ASSOCEDGECHAMFERACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swigregister", Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swiginit", Dwg_Object_ASSOCEDGECHAMFERACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCEDGEFILLETACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCEDGEFILLETACTIONBODY", _wrap_new_Dwg_Object_ASSOCEDGEFILLETACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCEDGEFILLETACTIONBODY", _wrap_delete_Dwg_Object_ASSOCEDGEFILLETACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swigregister", Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swiginit", Dwg_Object_ASSOCEDGEFILLETACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_b2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_get", _wrap_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_distance_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCTRIMSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCTRIMSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b2_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b3_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b4_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_b5_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_blend_options_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_get", _wrap_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_bs2_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCBLENDSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCBLENDSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt1_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_get", _wrap_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_pt2_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCFILLETSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCFILLETSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_sab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_pbsab_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY", _wrap_new_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY", _wrap_delete_Dwg_Object_ASSOCPATCHSURFACEACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swigregister", Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swiginit", Dwg_Object_ASSOCPATCHSURFACEACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_parent_set", _wrap_Dwg_ASSOCACTIONBODY_action_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_parent_get", _wrap_Dwg_ASSOCACTIONBODY_action_parent_get, METH_O, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_depid_set", _wrap_Dwg_ASSOCACTIONBODY_action_depid_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_depid_get", _wrap_Dwg_ASSOCACTIONBODY_action_depid_get, METH_O, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_dep_set", _wrap_Dwg_ASSOCACTIONBODY_action_dep_set, METH_VARARGS, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_dep_get", _wrap_Dwg_ASSOCACTIONBODY_action_dep_get, METH_O, NULL},
	 { "new_Dwg_ASSOCACTIONBODY_action", _wrap_new_Dwg_ASSOCACTIONBODY_action, METH_NOARGS, NULL},
	 { "delete_Dwg_ASSOCACTIONBODY_action", _wrap_delete_Dwg_ASSOCACTIONBODY_action, METH_O, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_swigregister", Dwg_ASSOCACTIONBODY_action_swigregister, METH_O, NULL},
	 { "Dwg_ASSOCACTIONBODY_action_swiginit", Dwg_ASSOCACTIONBODY_action_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_assoc_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_actions_get", _wrap_Dwg_Object_ASSOCMLEADERACTIONBODY_actions_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCMLEADERACTIONBODY", _wrap_new_Dwg_Object_ASSOCMLEADERACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCMLEADERACTIONBODY", _wrap_delete_Dwg_Object_ASSOCMLEADERACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_swigregister", Dwg_Object_ASSOCMLEADERACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCMLEADERACTIONBODY_swiginit", Dwg_Object_ASSOCMLEADERACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_assoc_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_r_node_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_get", _wrap_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_d_node_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY", _wrap_new_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY", _wrap_delete_Dwg_Object_ASSOCALIGNEDDIMACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swigregister", Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swiginit", Dwg_Object_ASSOCALIGNEDDIMACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assoc_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_r_node_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_d_node_get, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_get", _wrap_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_assocdep_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY", _wrap_new_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY", _wrap_delete_Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swigregister", Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swiginit", Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_assoc_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_r_node_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_get", _wrap_Dwg_Object_ASSOCORDINATEDIMACTIONBODY_d_node_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCORDINATEDIMACTIONBODY", _wrap_new_Dwg_Object_ASSOCORDINATEDIMACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCORDINATEDIMACTIONBODY", _wrap_delete_Dwg_Object_ASSOCORDINATEDIMACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swigregister", Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swiginit", Dwg_Object_ASSOCORDINATEDIMACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_assoc_dep_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_actionbody_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_r_node_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_get", _wrap_Dwg_Object_ASSOCROTATEDDIMACTIONBODY_d_node_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCROTATEDDIMACTIONBODY", _wrap_new_Dwg_Object_ASSOCROTATEDDIMACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCROTATEDDIMACTIONBODY", _wrap_delete_Dwg_Object_ASSOCROTATEDDIMACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swigregister", Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swiginit", Dwg_Object_ASSOCROTATEDDIMACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_get", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_get", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_adb_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_get", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_dimbase_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_get", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_name_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_get", _wrap_Dwg_Object_ASSOCDIMDEPENDENCYBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCDIMDEPENDENCYBODY", _wrap_new_Dwg_Object_ASSOCDIMDEPENDENCYBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCDIMDEPENDENCYBODY", _wrap_delete_Dwg_Object_ASSOCDIMDEPENDENCYBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_swigregister", Dwg_Object_ASSOCDIMDEPENDENCYBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCDIMDEPENDENCYBODY_swiginit", Dwg_Object_ASSOCDIMDEPENDENCYBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_get", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_get", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_adb_version_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_get", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_dimbase_version_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_get", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_get", _wrap_Dwg_Object_BLOCKPARAMDEPENDENCYBODY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPARAMDEPENDENCYBODY", _wrap_new_Dwg_Object_BLOCKPARAMDEPENDENCYBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPARAMDEPENDENCYBODY", _wrap_delete_Dwg_Object_BLOCKPARAMDEPENDENCYBODY, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swigregister", Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swiginit", Dwg_Object_BLOCKPARAMDEPENDENCYBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_parent_set", _wrap_Dwg_ARRAYITEMLOCATOR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_parent_get", _wrap_Dwg_ARRAYITEMLOCATOR_parent_get, METH_O, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_itemloc_set", _wrap_Dwg_ARRAYITEMLOCATOR_itemloc_set, METH_VARARGS, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_itemloc_get", _wrap_Dwg_ARRAYITEMLOCATOR_itemloc_get, METH_O, NULL},
	 { "new_Dwg_ARRAYITEMLOCATOR", _wrap_new_Dwg_ARRAYITEMLOCATOR, METH_NOARGS, NULL},
	 { "delete_Dwg_ARRAYITEMLOCATOR", _wrap_delete_Dwg_ARRAYITEMLOCATOR, METH_O, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_swigregister", Dwg_ARRAYITEMLOCATOR_swigregister, METH_O, NULL},
	 { "Dwg_ARRAYITEMLOCATOR_swiginit", Dwg_ARRAYITEMLOCATOR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_paramblock_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_get", _wrap_Dwg_Object_ASSOCARRAYACTIONBODY_transmatrix_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCARRAYACTIONBODY", _wrap_new_Dwg_Object_ASSOCARRAYACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCARRAYACTIONBODY", _wrap_delete_Dwg_Object_ASSOCARRAYACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_swigregister", Dwg_Object_ASSOCARRAYACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYACTIONBODY_swiginit", Dwg_Object_ASSOCARRAYACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_pab_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_aaab_version_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_paramblock_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_transmatrix_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_status_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_num_items_get, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_get", _wrap_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_items_get, METH_O, NULL},
	 { "new_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY", _wrap_new_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY", _wrap_delete_Dwg_Object_ASSOCARRAYMODIFYACTIONBODY, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swigregister", Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swiginit", Dwg_Object_ASSOCARRAYMODIFYACTIONBODY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_parentid_set", _wrap_Dwg_EvalExpr_parentid_set, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_parentid_get", _wrap_Dwg_EvalExpr_parentid_get, METH_O, NULL},
	 { "Dwg_EvalExpr_major_set", _wrap_Dwg_EvalExpr_major_set, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_major_get", _wrap_Dwg_EvalExpr_major_get, METH_O, NULL},
	 { "Dwg_EvalExpr_minor_set", _wrap_Dwg_EvalExpr_minor_set, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_minor_get", _wrap_Dwg_EvalExpr_minor_get, METH_O, NULL},
	 { "Dwg_EvalExpr_value_code_set", _wrap_Dwg_EvalExpr_value_code_set, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_value_code_get", _wrap_Dwg_EvalExpr_value_code_get, METH_O, NULL},
	 { "Dwg_EvalExpr_value_get", _wrap_Dwg_EvalExpr_value_get, METH_O, NULL},
	 { "Dwg_EvalExpr_nodeid_set", _wrap_Dwg_EvalExpr_nodeid_set, METH_VARARGS, NULL},
	 { "Dwg_EvalExpr_nodeid_get", _wrap_Dwg_EvalExpr_nodeid_get, METH_O, NULL},
	 { "new_Dwg_EvalExpr", _wrap_new_Dwg_EvalExpr, METH_NOARGS, NULL},
	 { "delete_Dwg_EvalExpr", _wrap_delete_Dwg_EvalExpr, METH_O, NULL},
	 { "Dwg_EvalExpr_swigregister", Dwg_EvalExpr_swigregister, METH_O, NULL},
	 { "Dwg_EvalExpr_swiginit", Dwg_EvalExpr_swiginit, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_num40_set", _wrap__dwg_EvalExpr_value_num40_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_num40_get", _wrap__dwg_EvalExpr_value_num40_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_pt2d_set", _wrap__dwg_EvalExpr_value_pt2d_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_pt2d_get", _wrap__dwg_EvalExpr_value_pt2d_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_pt3d_set", _wrap__dwg_EvalExpr_value_pt3d_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_pt3d_get", _wrap__dwg_EvalExpr_value_pt3d_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_text1_set", _wrap__dwg_EvalExpr_value_text1_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_text1_get", _wrap__dwg_EvalExpr_value_text1_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_long90_set", _wrap__dwg_EvalExpr_value_long90_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_long90_get", _wrap__dwg_EvalExpr_value_long90_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_handle91_set", _wrap__dwg_EvalExpr_value_handle91_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_handle91_get", _wrap__dwg_EvalExpr_value_handle91_get, METH_O, NULL},
	 { "_dwg_EvalExpr_value_short70_set", _wrap__dwg_EvalExpr_value_short70_set, METH_VARARGS, NULL},
	 { "_dwg_EvalExpr_value_short70_get", _wrap__dwg_EvalExpr_value_short70_get, METH_O, NULL},
	 { "new__dwg_EvalExpr_value", _wrap_new__dwg_EvalExpr_value, METH_NOARGS, NULL},
	 { "delete__dwg_EvalExpr_value", _wrap_delete__dwg_EvalExpr_value, METH_O, NULL},
	 { "_dwg_EvalExpr_value_swigregister", _dwg_EvalExpr_value_swigregister, METH_O, NULL},
	 { "_dwg_EvalExpr_value_swiginit", _dwg_EvalExpr_value_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentMaterial_major_set", _wrap_Dwg_ACSH_SubentMaterial_major_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentMaterial_major_get", _wrap_Dwg_ACSH_SubentMaterial_major_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentMaterial_minor_set", _wrap_Dwg_ACSH_SubentMaterial_minor_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentMaterial_minor_get", _wrap_Dwg_ACSH_SubentMaterial_minor_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentMaterial_reflectance_set", _wrap_Dwg_ACSH_SubentMaterial_reflectance_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentMaterial_reflectance_get", _wrap_Dwg_ACSH_SubentMaterial_reflectance_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentMaterial_displacement_set", _wrap_Dwg_ACSH_SubentMaterial_displacement_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentMaterial_displacement_get", _wrap_Dwg_ACSH_SubentMaterial_displacement_get, METH_O, NULL},
	 { "new_Dwg_ACSH_SubentMaterial", _wrap_new_Dwg_ACSH_SubentMaterial, METH_NOARGS, NULL},
	 { "delete_Dwg_ACSH_SubentMaterial", _wrap_delete_Dwg_ACSH_SubentMaterial, METH_O, NULL},
	 { "Dwg_ACSH_SubentMaterial_swigregister", Dwg_ACSH_SubentMaterial_swigregister, METH_O, NULL},
	 { "Dwg_ACSH_SubentMaterial_swiginit", Dwg_ACSH_SubentMaterial_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_major_set", _wrap_Dwg_ACSH_SubentColor_major_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_major_get", _wrap_Dwg_ACSH_SubentColor_major_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_minor_set", _wrap_Dwg_ACSH_SubentColor_minor_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_minor_get", _wrap_Dwg_ACSH_SubentColor_minor_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_transparency_set", _wrap_Dwg_ACSH_SubentColor_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_transparency_get", _wrap_Dwg_ACSH_SubentColor_transparency_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_bl93_set", _wrap_Dwg_ACSH_SubentColor_bl93_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_bl93_get", _wrap_Dwg_ACSH_SubentColor_bl93_get, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_is_face_variable_set", _wrap_Dwg_ACSH_SubentColor_is_face_variable_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_SubentColor_is_face_variable_get", _wrap_Dwg_ACSH_SubentColor_is_face_variable_get, METH_O, NULL},
	 { "new_Dwg_ACSH_SubentColor", _wrap_new_Dwg_ACSH_SubentColor, METH_NOARGS, NULL},
	 { "delete_Dwg_ACSH_SubentColor", _wrap_delete_Dwg_ACSH_SubentColor, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_swigregister", Dwg_ACSH_SubentColor_swigregister, METH_O, NULL},
	 { "Dwg_ACSH_SubentColor_swiginit", Dwg_ACSH_SubentColor_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_major_set", _wrap_Dwg_ACSH_HistoryNode_major_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_major_get", _wrap_Dwg_ACSH_HistoryNode_major_get, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_minor_set", _wrap_Dwg_ACSH_HistoryNode_minor_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_minor_get", _wrap_Dwg_ACSH_HistoryNode_minor_get, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_trans_set", _wrap_Dwg_ACSH_HistoryNode_trans_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_trans_get", _wrap_Dwg_ACSH_HistoryNode_trans_get, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_color_set", _wrap_Dwg_ACSH_HistoryNode_color_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_color_get", _wrap_Dwg_ACSH_HistoryNode_color_get, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_step_id_set", _wrap_Dwg_ACSH_HistoryNode_step_id_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_step_id_get", _wrap_Dwg_ACSH_HistoryNode_step_id_get, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_material_set", _wrap_Dwg_ACSH_HistoryNode_material_set, METH_VARARGS, NULL},
	 { "Dwg_ACSH_HistoryNode_material_get", _wrap_Dwg_ACSH_HistoryNode_material_get, METH_O, NULL},
	 { "new_Dwg_ACSH_HistoryNode", _wrap_new_Dwg_ACSH_HistoryNode, METH_NOARGS, NULL},
	 { "delete_Dwg_ACSH_HistoryNode", _wrap_delete_Dwg_ACSH_HistoryNode, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_swigregister", Dwg_ACSH_HistoryNode_swigregister, METH_O, NULL},
	 { "Dwg_ACSH_HistoryNode_swiginit", Dwg_ACSH_HistoryNode_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_parent_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_parent_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_major_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_major_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_minor_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_minor_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_owner_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_owner_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_owner_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_owner_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_h_nodeid_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_show_history_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_show_history_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_show_history_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_show_history_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_record_history_set", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_record_history_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_record_history_get", _wrap_Dwg_Object_ACSH_HISTORY_CLASS_record_history_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_HISTORY_CLASS", _wrap_new_Dwg_Object_ACSH_HISTORY_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_HISTORY_CLASS", _wrap_delete_Dwg_Object_ACSH_HISTORY_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_swigregister", Dwg_Object_ACSH_HISTORY_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_HISTORY_CLASS_swiginit", Dwg_Object_ACSH_HISTORY_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_parent_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_parent_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_major_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_major_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_minor_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_minor_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_length_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_length_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_length_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_width_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_width_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_width_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_height_set", _wrap_Dwg_Object_ACSH_BOX_CLASS_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_height_get", _wrap_Dwg_Object_ACSH_BOX_CLASS_height_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_BOX_CLASS", _wrap_new_Dwg_Object_ACSH_BOX_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_BOX_CLASS", _wrap_delete_Dwg_Object_ACSH_BOX_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_swigregister", Dwg_Object_ACSH_BOX_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOX_CLASS_swiginit", Dwg_Object_ACSH_BOX_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_parent_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_parent_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_major_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_major_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_minor_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_minor_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_length_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_length_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_length_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_width_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_width_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_width_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_height_set", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_height_get", _wrap_Dwg_Object_ACSH_WEDGE_CLASS_height_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_WEDGE_CLASS", _wrap_new_Dwg_Object_ACSH_WEDGE_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_WEDGE_CLASS", _wrap_delete_Dwg_Object_ACSH_WEDGE_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_swigregister", Dwg_Object_ACSH_WEDGE_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_WEDGE_CLASS_swiginit", Dwg_Object_ACSH_WEDGE_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_parent_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_major_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_major_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_minor_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operation_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operation_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand1_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_get", _wrap_Dwg_Object_ACSH_BOOLEAN_CLASS_operand2_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_BOOLEAN_CLASS", _wrap_new_Dwg_Object_ACSH_BOOLEAN_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_BOOLEAN_CLASS", _wrap_delete_Dwg_Object_ACSH_BOOLEAN_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_swigregister", Dwg_Object_ACSH_BOOLEAN_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_BOOLEAN_CLASS_swiginit", Dwg_Object_ACSH_BOOLEAN_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_parent_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_parent_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_unknown_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_unknown_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_unknown_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_version_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_version_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_version_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_blocks_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_blocks_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_blocks_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_block_size_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_block_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_block_size_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_block_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_encr_sat_data_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_sab_size_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_sab_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_sab_size_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_sab_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_data_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_data_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_data_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_wireframe_data_present_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_point_present_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_point_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_point_present_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_point_present_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_point_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_point_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_point_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_point_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_isolines_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_isolines_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_isolines_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_isolines_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_isoline_present_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_isoline_present_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_isoline_present_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_isoline_present_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_wires_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_wires_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_wires_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_wires_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_wires_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_wires_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_wires_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_silhouettes_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_silhouettes_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_silhouettes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_silhouettes_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_silhouettes_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set", _wrap_Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_get", _wrap_Dwg_Object_ACSH_BREP_CLASS__dxf_sab_converted_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty2_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty2_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_extra_acis_data_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_materials_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_num_materials_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_num_materials_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_materials_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_materials_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_materials_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_materials_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_guid_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_guid_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_guid_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_major_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_major_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_minor1_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor1_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_minor2_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_minor2_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_bytes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_revision_bytes_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_revision_bytes_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_end_marker_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_end_marker_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_end_marker_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_end_marker_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_history_id_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_history_id_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_history_id_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_history_id_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_has_revision_guid_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_acis_empty_bit_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_major_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_major_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_minor_set", _wrap_Dwg_Object_ACSH_BREP_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_minor_get", _wrap_Dwg_Object_ACSH_BREP_CLASS_minor_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_BREP_CLASS", _wrap_new_Dwg_Object_ACSH_BREP_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_BREP_CLASS", _wrap_delete_Dwg_Object_ACSH_BREP_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_swigregister", Dwg_Object_ACSH_BREP_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_BREP_CLASS_swiginit", Dwg_Object_ACSH_BREP_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_parent_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_parent_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_major_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_major_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_minor_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_minor_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_direction_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_direction_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_direction_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_bl92_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_bl92_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_bl92_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_bl93_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_text2_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_draft_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_start_draft_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_end_draft_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_scale_factor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_twist_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_align_angle_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_sweepentity_transform_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_pathentity_transform_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_align_option_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_align_option_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_align_option_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_miter_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_miter_option_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_miter_option_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_has_align_start_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_bank_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_bank_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_bank_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_bank_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_check_intersections_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b294_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b295_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_shsw_b296_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_pt2_set", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_pt2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_pt2_get", _wrap_Dwg_Object_ACSH_SWEEP_CLASS_pt2_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_SWEEP_CLASS", _wrap_new_Dwg_Object_ACSH_SWEEP_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_SWEEP_CLASS", _wrap_delete_Dwg_Object_ACSH_SWEEP_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_swigregister", Dwg_Object_ACSH_SWEEP_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_SWEEP_CLASS_swiginit", Dwg_Object_ACSH_SWEEP_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_parent_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_major_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_major_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_minor_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_direction_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_direction_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bl92_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_bl93_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_size_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_text2_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_draft_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_start_draft_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_end_draft_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_scale_factor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_twist_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_sweepentity_transform_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pathentity_transform_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_align_option_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_miter_option_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_has_align_start_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bank_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_bank_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_bank_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_check_intersections_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b294_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b295_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_shsw_b296_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_get", _wrap_Dwg_Object_ACSH_EXTRUSION_CLASS_pt2_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_EXTRUSION_CLASS", _wrap_new_Dwg_Object_ACSH_EXTRUSION_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_EXTRUSION_CLASS", _wrap_delete_Dwg_Object_ACSH_EXTRUSION_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_swigregister", Dwg_Object_ACSH_EXTRUSION_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_EXTRUSION_CLASS_swiginit", Dwg_Object_ACSH_EXTRUSION_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_parent_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_parent_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_major_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_major_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_minor_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_minor_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_num_crosssects_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_crosssects_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_crosssects_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_crosssects_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_crosssects_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_num_guides_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_num_guides_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_num_guides_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_num_guides_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_guides_set", _wrap_Dwg_Object_ACSH_LOFT_CLASS_guides_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_guides_get", _wrap_Dwg_Object_ACSH_LOFT_CLASS_guides_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_LOFT_CLASS", _wrap_new_Dwg_Object_ACSH_LOFT_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_LOFT_CLASS", _wrap_delete_Dwg_Object_ACSH_LOFT_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_swigregister", Dwg_Object_ACSH_LOFT_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_LOFT_CLASS_swiginit", Dwg_Object_ACSH_LOFT_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_parent_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_parent_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_major_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_major_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_minor_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_minor_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_bl92_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_bl92_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_bl92_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_edges_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_edges_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_edges_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_edges_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_edges_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_edges_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_radiuses_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_startsetbacks_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_num_endsetbacks_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_radiuses_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_radiuses_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_radiuses_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_radiuses_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_startsetbacks_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set", _wrap_Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_get", _wrap_Dwg_Object_ACSH_FILLET_CLASS_endsetbacks_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_FILLET_CLASS", _wrap_new_Dwg_Object_ACSH_FILLET_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_FILLET_CLASS", _wrap_delete_Dwg_Object_ACSH_FILLET_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_swigregister", Dwg_Object_ACSH_FILLET_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_FILLET_CLASS_swiginit", Dwg_Object_ACSH_FILLET_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_parent_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_parent_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_major_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_major_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_minor_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_minor_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_bl92_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl92_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_base_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_other_dist_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_num_edges_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_edges_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_edges_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_edges_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_edges_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl95_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_bl95_get", _wrap_Dwg_Object_ACSH_CHAMFER_CLASS_bl95_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_CHAMFER_CLASS", _wrap_new_Dwg_Object_ACSH_CHAMFER_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_CHAMFER_CLASS", _wrap_delete_Dwg_Object_ACSH_CHAMFER_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_swigregister", Dwg_Object_ACSH_CHAMFER_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_CHAMFER_CLASS_swiginit", Dwg_Object_ACSH_CHAMFER_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_parent_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_parent_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_major_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_major_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_minor_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_minor_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_height_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_height_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_height_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_major_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_minor_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_get", _wrap_Dwg_Object_ACSH_CYLINDER_CLASS_x_radius_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_CYLINDER_CLASS", _wrap_new_Dwg_Object_ACSH_CYLINDER_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_CYLINDER_CLASS", _wrap_delete_Dwg_Object_ACSH_CYLINDER_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_swigregister", Dwg_Object_ACSH_CYLINDER_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_CYLINDER_CLASS_swiginit", Dwg_Object_ACSH_CYLINDER_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_parent_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_parent_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_major_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_major_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_minor_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_minor_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_height_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_height_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_height_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_major_radius_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_major_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_major_radius_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_major_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_minor_radius_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_minor_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_minor_radius_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_minor_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_x_radius_set", _wrap_Dwg_Object_ACSH_CONE_CLASS_x_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_x_radius_get", _wrap_Dwg_Object_ACSH_CONE_CLASS_x_radius_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_CONE_CLASS", _wrap_new_Dwg_Object_ACSH_CONE_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_CONE_CLASS", _wrap_delete_Dwg_Object_ACSH_CONE_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_swigregister", Dwg_Object_ACSH_CONE_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_CONE_CLASS_swiginit", Dwg_Object_ACSH_CONE_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_parent_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_parent_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_major_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_major_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_minor_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_minor_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_height_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_height_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_height_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_sides_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_sides_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_sides_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_sides_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_radius_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_radius_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_topradius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_topradius_get", _wrap_Dwg_Object_ACSH_PYRAMID_CLASS_topradius_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_PYRAMID_CLASS", _wrap_new_Dwg_Object_ACSH_PYRAMID_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_PYRAMID_CLASS", _wrap_delete_Dwg_Object_ACSH_PYRAMID_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_swigregister", Dwg_Object_ACSH_PYRAMID_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_PYRAMID_CLASS_swiginit", Dwg_Object_ACSH_PYRAMID_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_parent_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_parent_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_major_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_major_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_minor_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_minor_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_radius_set", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_radius_get", _wrap_Dwg_Object_ACSH_SPHERE_CLASS_radius_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_SPHERE_CLASS", _wrap_new_Dwg_Object_ACSH_SPHERE_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_SPHERE_CLASS", _wrap_delete_Dwg_Object_ACSH_SPHERE_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_swigregister", Dwg_Object_ACSH_SPHERE_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_SPHERE_CLASS_swiginit", Dwg_Object_ACSH_SPHERE_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_parent_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_parent_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_major_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_major_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_minor_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_minor_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_major_radius_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_major_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_major_radius_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_major_radius_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set", _wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_minor_radius_get", _wrap_Dwg_Object_ACSH_TORUS_CLASS_minor_radius_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_TORUS_CLASS", _wrap_new_Dwg_Object_ACSH_TORUS_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_TORUS_CLASS", _wrap_delete_Dwg_Object_ACSH_TORUS_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_swigregister", Dwg_Object_ACSH_TORUS_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_TORUS_CLASS_swiginit", Dwg_Object_ACSH_TORUS_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_parent_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_parent_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_history_node_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_history_node_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_history_node_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_major_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_major_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_major_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_minor_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_minor_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_minor_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_axis_pt_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_direction_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_direction_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_direction_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_revolve_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_start_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_draft_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd44_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_bd44_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd44_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd45_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_bd45_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_bd45_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_twist_angle_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_b290_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_b290_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_b290_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_b290_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_is_close_to_axis_get, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_get", _wrap_Dwg_Object_ACSH_REVOLVE_CLASS_sweep_entity_get, METH_O, NULL},
	 { "new_Dwg_Object_ACSH_REVOLVE_CLASS", _wrap_new_Dwg_Object_ACSH_REVOLVE_CLASS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACSH_REVOLVE_CLASS", _wrap_delete_Dwg_Object_ACSH_REVOLVE_CLASS, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_swigregister", Dwg_Object_ACSH_REVOLVE_CLASS_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACSH_REVOLVE_CLASS_swiginit", Dwg_Object_ACSH_REVOLVE_CLASS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_parent_set", _wrap_Dwg_Entity_NAVISWORKSMODEL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_parent_get", _wrap_Dwg_Entity_NAVISWORKSMODEL_parent_get, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_flags_set", _wrap_Dwg_Entity_NAVISWORKSMODEL_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_flags_get", _wrap_Dwg_Entity_NAVISWORKSMODEL_flags_get, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_definition_set", _wrap_Dwg_Entity_NAVISWORKSMODEL_definition_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_definition_get", _wrap_Dwg_Entity_NAVISWORKSMODEL_definition_get, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_transmatrix_set", _wrap_Dwg_Entity_NAVISWORKSMODEL_transmatrix_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_transmatrix_get", _wrap_Dwg_Entity_NAVISWORKSMODEL_transmatrix_get, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_unitfactor_set", _wrap_Dwg_Entity_NAVISWORKSMODEL_unitfactor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_unitfactor_get", _wrap_Dwg_Entity_NAVISWORKSMODEL_unitfactor_get, METH_O, NULL},
	 { "new_Dwg_Entity_NAVISWORKSMODEL", _wrap_new_Dwg_Entity_NAVISWORKSMODEL, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_NAVISWORKSMODEL", _wrap_delete_Dwg_Entity_NAVISWORKSMODEL, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_swigregister", Dwg_Entity_NAVISWORKSMODEL_swigregister, METH_O, NULL},
	 { "Dwg_Entity_NAVISWORKSMODEL_swiginit", Dwg_Entity_NAVISWORKSMODEL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_parent_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_parent_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_parent_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_flags_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_flags_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_flags_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_path_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_path_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_path_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_path_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_status_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_status_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_status_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_status_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_min_extent_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_min_extent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_min_extent_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_min_extent_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_max_extent_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_max_extent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_max_extent_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_max_extent_get, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set", _wrap_Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_set, METH_VARARGS, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_get", _wrap_Dwg_Object_NAVISWORKSMODELDEF_host_drawing_visibility_get, METH_O, NULL},
	 { "new_Dwg_Object_NAVISWORKSMODELDEF", _wrap_new_Dwg_Object_NAVISWORKSMODELDEF, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_NAVISWORKSMODELDEF", _wrap_delete_Dwg_Object_NAVISWORKSMODELDEF, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_swigregister", Dwg_Object_NAVISWORKSMODELDEF_swigregister, METH_O, NULL},
	 { "Dwg_Object_NAVISWORKSMODELDEF_swiginit", Dwg_Object_NAVISWORKSMODELDEF_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_parent_set", _wrap_Dwg_Object_RENDERSETTINGS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_parent_get", _wrap_Dwg_Object_RENDERSETTINGS_parent_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_class_version_set", _wrap_Dwg_Object_RENDERSETTINGS_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_class_version_get", _wrap_Dwg_Object_RENDERSETTINGS_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_name_set", _wrap_Dwg_Object_RENDERSETTINGS_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_name_get", _wrap_Dwg_Object_RENDERSETTINGS_name_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_fog_enabled_set", _wrap_Dwg_Object_RENDERSETTINGS_fog_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_fog_enabled_get", _wrap_Dwg_Object_RENDERSETTINGS_fog_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_fog_background_enabled_set", _wrap_Dwg_Object_RENDERSETTINGS_fog_background_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_fog_background_enabled_get", _wrap_Dwg_Object_RENDERSETTINGS_fog_background_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_backfaces_enabled_set", _wrap_Dwg_Object_RENDERSETTINGS_backfaces_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_backfaces_enabled_get", _wrap_Dwg_Object_RENDERSETTINGS_backfaces_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_environ_image_enabled_set", _wrap_Dwg_Object_RENDERSETTINGS_environ_image_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_environ_image_enabled_get", _wrap_Dwg_Object_RENDERSETTINGS_environ_image_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_environ_image_filename_set", _wrap_Dwg_Object_RENDERSETTINGS_environ_image_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_environ_image_filename_get", _wrap_Dwg_Object_RENDERSETTINGS_environ_image_filename_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_description_set", _wrap_Dwg_Object_RENDERSETTINGS_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_description_get", _wrap_Dwg_Object_RENDERSETTINGS_description_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_display_index_set", _wrap_Dwg_Object_RENDERSETTINGS_display_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_display_index_get", _wrap_Dwg_Object_RENDERSETTINGS_display_index_get, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_has_predefined_set", _wrap_Dwg_Object_RENDERSETTINGS_has_predefined_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERSETTINGS_has_predefined_get", _wrap_Dwg_Object_RENDERSETTINGS_has_predefined_get, METH_O, NULL},
	 { "new_Dwg_Object_RENDERSETTINGS", _wrap_new_Dwg_Object_RENDERSETTINGS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RENDERSETTINGS", _wrap_delete_Dwg_Object_RENDERSETTINGS, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_swigregister", Dwg_Object_RENDERSETTINGS_swigregister, METH_O, NULL},
	 { "Dwg_Object_RENDERSETTINGS_swiginit", Dwg_Object_RENDERSETTINGS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_parent_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_parent_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_name_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_name_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_name_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fog_background_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_backfaces_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_environ_image_filename_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_description_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_description_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_description_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_display_index_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_has_predefined_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_version_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_mr_filter_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_filter2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color3_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_sampling_contrast_color4_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_shadow_maps_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_tracing_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_ray_trace_depth3_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_global_illumination_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_count_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_sample_radius_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_gi_photons_per_light_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_photon_trace_depth3_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_final_gathering_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_ray_count_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius_state3_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius1_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_fg_sample_radius2_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_light_luminance_scale_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_grid_float_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_photon_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_bsp_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_export_mi_enabled_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_mr_description_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_size_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_tile_order_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_memory_limit_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_diagnostics_samples_mode_get, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_get", _wrap_Dwg_Object_MENTALRAYRENDERSETTINGS_energy_multiplier_get, METH_O, NULL},
	 { "new_Dwg_Object_MENTALRAYRENDERSETTINGS", _wrap_new_Dwg_Object_MENTALRAYRENDERSETTINGS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MENTALRAYRENDERSETTINGS", _wrap_delete_Dwg_Object_MENTALRAYRENDERSETTINGS, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_swigregister", Dwg_Object_MENTALRAYRENDERSETTINGS_swigregister, METH_O, NULL},
	 { "Dwg_Object_MENTALRAYRENDERSETTINGS_swiginit", Dwg_Object_MENTALRAYRENDERSETTINGS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_parent_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_parent_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_name_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_name_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_name_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_fog_background_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_backfaces_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_environ_image_filename_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_description_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_description_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_description_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_display_index_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_has_predefined_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_rapidrt_version_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_target_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_level_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_render_time_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_lighting_model_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_type_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_width_get, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_get", _wrap_Dwg_Object_RAPIDRTRENDERSETTINGS_filter_height_get, METH_O, NULL},
	 { "new_Dwg_Object_RAPIDRTRENDERSETTINGS", _wrap_new_Dwg_Object_RAPIDRTRENDERSETTINGS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RAPIDRTRENDERSETTINGS", _wrap_delete_Dwg_Object_RAPIDRTRENDERSETTINGS, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_swigregister", Dwg_Object_RAPIDRTRENDERSETTINGS_swigregister, METH_O, NULL},
	 { "Dwg_Object_RAPIDRTRENDERSETTINGS_swiginit", Dwg_Object_RAPIDRTRENDERSETTINGS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_parent_set", _wrap_Dwg_Object_RENDERENVIRONMENT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_parent_get", _wrap_Dwg_Object_RENDERENVIRONMENT_parent_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_class_version_set", _wrap_Dwg_Object_RENDERENVIRONMENT_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_class_version_get", _wrap_Dwg_Object_RENDERENVIRONMENT_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_enabled_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_enabled_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_background_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_r_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_r_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_r_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_r_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_g_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_g_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_g_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_g_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_b_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_b_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_color_b_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_color_b_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_density_near_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_near_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_density_near_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_near_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_density_far_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_far_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_density_far_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_density_far_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_near_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_distance_near_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_near_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_far_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_fog_distance_far_get", _wrap_Dwg_Object_RENDERENVIRONMENT_fog_distance_far_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set", _wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_get", _wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set", _wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_environ_image_filename_get", _wrap_Dwg_Object_RENDERENVIRONMENT_environ_image_filename_get, METH_O, NULL},
	 { "new_Dwg_Object_RENDERENVIRONMENT", _wrap_new_Dwg_Object_RENDERENVIRONMENT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RENDERENVIRONMENT", _wrap_delete_Dwg_Object_RENDERENVIRONMENT, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_swigregister", Dwg_Object_RENDERENVIRONMENT_swigregister, METH_O, NULL},
	 { "Dwg_Object_RENDERENVIRONMENT_swiginit", Dwg_Object_RENDERENVIRONMENT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_parent_set", _wrap_Dwg_Object_RENDERGLOBAL_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_parent_get", _wrap_Dwg_Object_RENDERGLOBAL_parent_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_class_version_set", _wrap_Dwg_Object_RENDERGLOBAL_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_class_version_get", _wrap_Dwg_Object_RENDERGLOBAL_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_procedure_set", _wrap_Dwg_Object_RENDERGLOBAL_procedure_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_procedure_get", _wrap_Dwg_Object_RENDERGLOBAL_procedure_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_destination_set", _wrap_Dwg_Object_RENDERGLOBAL_destination_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_destination_get", _wrap_Dwg_Object_RENDERGLOBAL_destination_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_save_enabled_set", _wrap_Dwg_Object_RENDERGLOBAL_save_enabled_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_save_enabled_get", _wrap_Dwg_Object_RENDERGLOBAL_save_enabled_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_save_filename_set", _wrap_Dwg_Object_RENDERGLOBAL_save_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_save_filename_get", _wrap_Dwg_Object_RENDERGLOBAL_save_filename_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_image_width_set", _wrap_Dwg_Object_RENDERGLOBAL_image_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_image_width_get", _wrap_Dwg_Object_RENDERGLOBAL_image_width_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_image_height_set", _wrap_Dwg_Object_RENDERGLOBAL_image_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_image_height_get", _wrap_Dwg_Object_RENDERGLOBAL_image_height_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_predef_presets_first_set", _wrap_Dwg_Object_RENDERGLOBAL_predef_presets_first_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_predef_presets_first_get", _wrap_Dwg_Object_RENDERGLOBAL_predef_presets_first_get, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_highlevel_info_set", _wrap_Dwg_Object_RENDERGLOBAL_highlevel_info_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERGLOBAL_highlevel_info_get", _wrap_Dwg_Object_RENDERGLOBAL_highlevel_info_get, METH_O, NULL},
	 { "new_Dwg_Object_RENDERGLOBAL", _wrap_new_Dwg_Object_RENDERGLOBAL, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RENDERGLOBAL", _wrap_delete_Dwg_Object_RENDERGLOBAL, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_swigregister", Dwg_Object_RENDERGLOBAL_swigregister, METH_O, NULL},
	 { "Dwg_Object_RENDERGLOBAL_swiginit", Dwg_Object_RENDERGLOBAL_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_parent_set", _wrap_Dwg_Object_RENDERENTRY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_parent_get", _wrap_Dwg_Object_RENDERENTRY_parent_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_class_version_set", _wrap_Dwg_Object_RENDERENTRY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_class_version_get", _wrap_Dwg_Object_RENDERENTRY_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_image_file_name_set", _wrap_Dwg_Object_RENDERENTRY_image_file_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_image_file_name_get", _wrap_Dwg_Object_RENDERENTRY_image_file_name_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_preset_name_set", _wrap_Dwg_Object_RENDERENTRY_preset_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_preset_name_get", _wrap_Dwg_Object_RENDERENTRY_preset_name_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_view_name_set", _wrap_Dwg_Object_RENDERENTRY_view_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_view_name_get", _wrap_Dwg_Object_RENDERENTRY_view_name_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_dimension_x_set", _wrap_Dwg_Object_RENDERENTRY_dimension_x_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_dimension_x_get", _wrap_Dwg_Object_RENDERENTRY_dimension_x_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_dimension_y_set", _wrap_Dwg_Object_RENDERENTRY_dimension_y_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_dimension_y_get", _wrap_Dwg_Object_RENDERENTRY_dimension_y_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_year_set", _wrap_Dwg_Object_RENDERENTRY_start_year_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_year_get", _wrap_Dwg_Object_RENDERENTRY_start_year_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_month_set", _wrap_Dwg_Object_RENDERENTRY_start_month_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_month_get", _wrap_Dwg_Object_RENDERENTRY_start_month_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_day_set", _wrap_Dwg_Object_RENDERENTRY_start_day_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_day_get", _wrap_Dwg_Object_RENDERENTRY_start_day_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_minute_set", _wrap_Dwg_Object_RENDERENTRY_start_minute_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_minute_get", _wrap_Dwg_Object_RENDERENTRY_start_minute_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_second_set", _wrap_Dwg_Object_RENDERENTRY_start_second_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_second_get", _wrap_Dwg_Object_RENDERENTRY_start_second_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_start_msec_set", _wrap_Dwg_Object_RENDERENTRY_start_msec_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_start_msec_get", _wrap_Dwg_Object_RENDERENTRY_start_msec_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_render_time_set", _wrap_Dwg_Object_RENDERENTRY_render_time_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_render_time_get", _wrap_Dwg_Object_RENDERENTRY_render_time_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_memory_amount_set", _wrap_Dwg_Object_RENDERENTRY_memory_amount_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_memory_amount_get", _wrap_Dwg_Object_RENDERENTRY_memory_amount_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_material_count_set", _wrap_Dwg_Object_RENDERENTRY_material_count_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_material_count_get", _wrap_Dwg_Object_RENDERENTRY_material_count_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_light_count_set", _wrap_Dwg_Object_RENDERENTRY_light_count_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_light_count_get", _wrap_Dwg_Object_RENDERENTRY_light_count_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_triangle_count_set", _wrap_Dwg_Object_RENDERENTRY_triangle_count_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_triangle_count_get", _wrap_Dwg_Object_RENDERENTRY_triangle_count_get, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_display_index_set", _wrap_Dwg_Object_RENDERENTRY_display_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RENDERENTRY_display_index_get", _wrap_Dwg_Object_RENDERENTRY_display_index_get, METH_O, NULL},
	 { "new_Dwg_Object_RENDERENTRY", _wrap_new_Dwg_Object_RENDERENTRY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RENDERENTRY", _wrap_delete_Dwg_Object_RENDERENTRY, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_swigregister", Dwg_Object_RENDERENTRY_swigregister, METH_O, NULL},
	 { "Dwg_Object_RENDERENTRY_swiginit", Dwg_Object_RENDERENTRY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_parent_set", _wrap_Dwg_Object_MOTIONPATH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_parent_get", _wrap_Dwg_Object_MOTIONPATH_parent_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_class_version_set", _wrap_Dwg_Object_MOTIONPATH_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_class_version_get", _wrap_Dwg_Object_MOTIONPATH_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_camera_path_set", _wrap_Dwg_Object_MOTIONPATH_camera_path_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_camera_path_get", _wrap_Dwg_Object_MOTIONPATH_camera_path_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_target_path_set", _wrap_Dwg_Object_MOTIONPATH_target_path_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_target_path_get", _wrap_Dwg_Object_MOTIONPATH_target_path_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_viewtable_set", _wrap_Dwg_Object_MOTIONPATH_viewtable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_viewtable_get", _wrap_Dwg_Object_MOTIONPATH_viewtable_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_frames_set", _wrap_Dwg_Object_MOTIONPATH_frames_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_frames_get", _wrap_Dwg_Object_MOTIONPATH_frames_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_frame_rate_set", _wrap_Dwg_Object_MOTIONPATH_frame_rate_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_frame_rate_get", _wrap_Dwg_Object_MOTIONPATH_frame_rate_get, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_corner_decel_set", _wrap_Dwg_Object_MOTIONPATH_corner_decel_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MOTIONPATH_corner_decel_get", _wrap_Dwg_Object_MOTIONPATH_corner_decel_get, METH_O, NULL},
	 { "new_Dwg_Object_MOTIONPATH", _wrap_new_Dwg_Object_MOTIONPATH, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MOTIONPATH", _wrap_delete_Dwg_Object_MOTIONPATH, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_swigregister", Dwg_Object_MOTIONPATH_swigregister, METH_O, NULL},
	 { "Dwg_Object_MOTIONPATH_swiginit", Dwg_Object_MOTIONPATH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_CURVEPATH_parent_set", _wrap_Dwg_Object_CURVEPATH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CURVEPATH_parent_get", _wrap_Dwg_Object_CURVEPATH_parent_get, METH_O, NULL},
	 { "Dwg_Object_CURVEPATH_class_version_set", _wrap_Dwg_Object_CURVEPATH_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CURVEPATH_class_version_get", _wrap_Dwg_Object_CURVEPATH_class_version_get, METH_O, NULL},
	 { "Dwg_Object_CURVEPATH_entity_set", _wrap_Dwg_Object_CURVEPATH_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CURVEPATH_entity_get", _wrap_Dwg_Object_CURVEPATH_entity_get, METH_O, NULL},
	 { "new_Dwg_Object_CURVEPATH", _wrap_new_Dwg_Object_CURVEPATH, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_CURVEPATH", _wrap_delete_Dwg_Object_CURVEPATH, METH_O, NULL},
	 { "Dwg_Object_CURVEPATH_swigregister", Dwg_Object_CURVEPATH_swigregister, METH_O, NULL},
	 { "Dwg_Object_CURVEPATH_swiginit", Dwg_Object_CURVEPATH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTPATH_parent_set", _wrap_Dwg_Object_POINTPATH_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTPATH_parent_get", _wrap_Dwg_Object_POINTPATH_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTPATH_class_version_set", _wrap_Dwg_Object_POINTPATH_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTPATH_class_version_get", _wrap_Dwg_Object_POINTPATH_class_version_get, METH_O, NULL},
	 { "Dwg_Object_POINTPATH_point_set", _wrap_Dwg_Object_POINTPATH_point_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTPATH_point_get", _wrap_Dwg_Object_POINTPATH_point_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTPATH", _wrap_new_Dwg_Object_POINTPATH, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTPATH", _wrap_delete_Dwg_Object_POINTPATH, METH_O, NULL},
	 { "Dwg_Object_POINTPATH_swigregister", Dwg_Object_POINTPATH_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTPATH_swiginit", Dwg_Object_POINTPATH_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_parent_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_parent_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_parent_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_flags_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_flags_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_flags_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_max_regen_threads_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_use_lut_palette_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hlt_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_alt_hltcolor_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_geom_shader_usage_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_blending_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_blending_mode_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_blending_mode_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_antialiasing_level_get, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_bd2_set", _wrap_Dwg_Object_TVDEVICEPROPERTIES_bd2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_bd2_get", _wrap_Dwg_Object_TVDEVICEPROPERTIES_bd2_get, METH_O, NULL},
	 { "new_Dwg_Object_TVDEVICEPROPERTIES", _wrap_new_Dwg_Object_TVDEVICEPROPERTIES, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_TVDEVICEPROPERTIES", _wrap_delete_Dwg_Object_TVDEVICEPROPERTIES, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_swigregister", Dwg_Object_TVDEVICEPROPERTIES_swigregister, METH_O, NULL},
	 { "Dwg_Object_TVDEVICEPROPERTIES_swiginit", Dwg_Object_TVDEVICEPROPERTIES_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_parent_set", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_parent_get", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_class_version_get", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_sunid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_sunid_get", _wrap_Dwg_Object_SKYLIGHT_BACKGROUND_sunid_get, METH_O, NULL},
	 { "new_Dwg_Object_SKYLIGHT_BACKGROUND", _wrap_new_Dwg_Object_SKYLIGHT_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SKYLIGHT_BACKGROUND", _wrap_delete_Dwg_Object_SKYLIGHT_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_swigregister", Dwg_Object_SKYLIGHT_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_SKYLIGHT_BACKGROUND_swiginit", Dwg_Object_SKYLIGHT_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_parent_set", _wrap_Dwg_Object_SOLID_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_parent_get", _wrap_Dwg_Object_SOLID_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_class_version_set", _wrap_Dwg_Object_SOLID_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_class_version_get", _wrap_Dwg_Object_SOLID_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_color_set", _wrap_Dwg_Object_SOLID_BACKGROUND_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_color_get", _wrap_Dwg_Object_SOLID_BACKGROUND_color_get, METH_O, NULL},
	 { "new_Dwg_Object_SOLID_BACKGROUND", _wrap_new_Dwg_Object_SOLID_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SOLID_BACKGROUND", _wrap_delete_Dwg_Object_SOLID_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_swigregister", Dwg_Object_SOLID_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_SOLID_BACKGROUND_swiginit", Dwg_Object_SOLID_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_parent_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_parent_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_class_version_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_class_version_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_filename_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_filename_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_filename_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_fit_to_screen_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_maintain_aspect_ratio_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_use_tiling_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_use_tiling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_use_tiling_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_use_tiling_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_offset_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_offset_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_offset_get, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_scale_set", _wrap_Dwg_Object_IMAGE_BACKGROUND_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_scale_get", _wrap_Dwg_Object_IMAGE_BACKGROUND_scale_get, METH_O, NULL},
	 { "new_Dwg_Object_IMAGE_BACKGROUND", _wrap_new_Dwg_Object_IMAGE_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_IMAGE_BACKGROUND", _wrap_delete_Dwg_Object_IMAGE_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_swigregister", Dwg_Object_IMAGE_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_IMAGE_BACKGROUND_swiginit", Dwg_Object_IMAGE_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_parent_set", _wrap_Dwg_Object_IBL_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_parent_get", _wrap_Dwg_Object_IBL_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_class_version_set", _wrap_Dwg_Object_IBL_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_class_version_get", _wrap_Dwg_Object_IBL_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_enable_set", _wrap_Dwg_Object_IBL_BACKGROUND_enable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_enable_get", _wrap_Dwg_Object_IBL_BACKGROUND_enable_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_name_set", _wrap_Dwg_Object_IBL_BACKGROUND_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_name_get", _wrap_Dwg_Object_IBL_BACKGROUND_name_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_rotation_set", _wrap_Dwg_Object_IBL_BACKGROUND_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_rotation_get", _wrap_Dwg_Object_IBL_BACKGROUND_rotation_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_display_image_set", _wrap_Dwg_Object_IBL_BACKGROUND_display_image_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_display_image_get", _wrap_Dwg_Object_IBL_BACKGROUND_display_image_get, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_secondary_background_set", _wrap_Dwg_Object_IBL_BACKGROUND_secondary_background_set, METH_VARARGS, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_secondary_background_get", _wrap_Dwg_Object_IBL_BACKGROUND_secondary_background_get, METH_O, NULL},
	 { "new_Dwg_Object_IBL_BACKGROUND", _wrap_new_Dwg_Object_IBL_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_IBL_BACKGROUND", _wrap_delete_Dwg_Object_IBL_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_swigregister", Dwg_Object_IBL_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_IBL_BACKGROUND_swiginit", Dwg_Object_IBL_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_parent_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_parent_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_class_version_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_class_version_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_top_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_top_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_top_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_top_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_middle_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_middle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_middle_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_middle_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_bottom_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_color_bottom_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_color_bottom_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_horizon_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_horizon_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_horizon_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_horizon_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_height_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_height_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_height_get, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_rotation_set", _wrap_Dwg_Object_GRADIENT_BACKGROUND_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_rotation_get", _wrap_Dwg_Object_GRADIENT_BACKGROUND_rotation_get, METH_O, NULL},
	 { "new_Dwg_Object_GRADIENT_BACKGROUND", _wrap_new_Dwg_Object_GRADIENT_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_GRADIENT_BACKGROUND", _wrap_delete_Dwg_Object_GRADIENT_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_swigregister", Dwg_Object_GRADIENT_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_GRADIENT_BACKGROUND_swiginit", Dwg_Object_GRADIENT_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_parent_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_parent_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_class_version_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_zenith_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_sky_horizon_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_horizon_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_underground_azimuth_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_near_get, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_set, METH_VARARGS, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_get", _wrap_Dwg_Object_GROUND_PLANE_BACKGROUND_color_far_get, METH_O, NULL},
	 { "new_Dwg_Object_GROUND_PLANE_BACKGROUND", _wrap_new_Dwg_Object_GROUND_PLANE_BACKGROUND, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_GROUND_PLANE_BACKGROUND", _wrap_delete_Dwg_Object_GROUND_PLANE_BACKGROUND, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_swigregister", Dwg_Object_GROUND_PLANE_BACKGROUND_swigregister, METH_O, NULL},
	 { "Dwg_Object_GROUND_PLANE_BACKGROUND_swiginit", Dwg_Object_GROUND_PLANE_BACKGROUND_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "new_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swigregister", Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swiginit", Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_dict_parent_set", _wrap_Dwg_CONTEXTDATA_dict_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_dict_parent_get", _wrap_Dwg_CONTEXTDATA_dict_parent_get, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_dict_text_set", _wrap_Dwg_CONTEXTDATA_dict_text_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_dict_text_get", _wrap_Dwg_CONTEXTDATA_dict_text_get, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_dict_itemhandle_set", _wrap_Dwg_CONTEXTDATA_dict_itemhandle_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_dict_itemhandle_get", _wrap_Dwg_CONTEXTDATA_dict_itemhandle_get, METH_O, NULL},
	 { "new_Dwg_CONTEXTDATA_dict", _wrap_new_Dwg_CONTEXTDATA_dict, METH_NOARGS, NULL},
	 { "delete_Dwg_CONTEXTDATA_dict", _wrap_delete_Dwg_CONTEXTDATA_dict, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_dict_swigregister", Dwg_CONTEXTDATA_dict_swigregister, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_dict_swiginit", Dwg_CONTEXTDATA_dict_swiginit, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_submgr_parent_set", _wrap_Dwg_CONTEXTDATA_submgr_parent_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_submgr_parent_get", _wrap_Dwg_CONTEXTDATA_submgr_parent_get, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_submgr_handle_set", _wrap_Dwg_CONTEXTDATA_submgr_handle_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_submgr_handle_get", _wrap_Dwg_CONTEXTDATA_submgr_handle_get, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_submgr_num_entries_set", _wrap_Dwg_CONTEXTDATA_submgr_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_submgr_num_entries_get", _wrap_Dwg_CONTEXTDATA_submgr_num_entries_get, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_submgr_entries_set", _wrap_Dwg_CONTEXTDATA_submgr_entries_set, METH_VARARGS, NULL},
	 { "Dwg_CONTEXTDATA_submgr_entries_get", _wrap_Dwg_CONTEXTDATA_submgr_entries_get, METH_O, NULL},
	 { "new_Dwg_CONTEXTDATA_submgr", _wrap_new_Dwg_CONTEXTDATA_submgr, METH_NOARGS, NULL},
	 { "delete_Dwg_CONTEXTDATA_submgr", _wrap_delete_Dwg_CONTEXTDATA_submgr, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_submgr_swigregister", Dwg_CONTEXTDATA_submgr_swigregister, METH_O, NULL},
	 { "Dwg_CONTEXTDATA_submgr_swiginit", Dwg_CONTEXTDATA_submgr_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_parent_set", _wrap_Dwg_Object_CONTEXTDATAMANAGER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_parent_get", _wrap_Dwg_Object_CONTEXTDATAMANAGER_parent_get, METH_O, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set", _wrap_Dwg_Object_CONTEXTDATAMANAGER_objectcontext_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_objectcontext_get", _wrap_Dwg_Object_CONTEXTDATAMANAGER_objectcontext_get, METH_O, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set", _wrap_Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_get", _wrap_Dwg_Object_CONTEXTDATAMANAGER_num_submgrs_get, METH_O, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_submgrs_set", _wrap_Dwg_Object_CONTEXTDATAMANAGER_submgrs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_submgrs_get", _wrap_Dwg_Object_CONTEXTDATAMANAGER_submgrs_get, METH_O, NULL},
	 { "new_Dwg_Object_CONTEXTDATAMANAGER", _wrap_new_Dwg_Object_CONTEXTDATAMANAGER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_CONTEXTDATAMANAGER", _wrap_delete_Dwg_Object_CONTEXTDATAMANAGER, METH_O, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_swigregister", Dwg_Object_CONTEXTDATAMANAGER_swigregister, METH_O, NULL},
	 { "Dwg_Object_CONTEXTDATAMANAGER_swiginit", Dwg_Object_CONTEXTDATAMANAGER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_horizontal_mode_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_rotation_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_ins_pt_get, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_get", _wrap_Dwg_Object_TEXTOBJECTCONTEXTDATA_alignment_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_TEXTOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_TEXTOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_TEXTOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_TEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_swigregister", Dwg_Object_TEXTOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_TEXTOBJECTCONTEXTDATA_swiginit", Dwg_Object_TEXTOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_attachment_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_ins_pt_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_x_axis_dir_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_height_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_rect_width_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_width_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_extents_height_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_type_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_width_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_gutter_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_auto_height_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_flow_reversed_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_num_column_heights_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_get", _wrap_Dwg_Object_MTEXTOBJECTCONTEXTDATA_column_heights_get, METH_O, NULL},
	 { "new_Dwg_Object_MTEXTOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_MTEXTOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MTEXTOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_MTEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_swigregister", Dwg_Object_MTEXTOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_MTEXTOBJECTCONTEXTDATA_swiginit", Dwg_Object_MTEXTOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_b293_set", _wrap_Dwg_OCD_Dimension_b293_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_b293_get", _wrap_Dwg_OCD_Dimension_b293_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_def_pt_set", _wrap_Dwg_OCD_Dimension_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_def_pt_get", _wrap_Dwg_OCD_Dimension_def_pt_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_is_def_textloc_set", _wrap_Dwg_OCD_Dimension_is_def_textloc_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_is_def_textloc_get", _wrap_Dwg_OCD_Dimension_is_def_textloc_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_text_rotation_set", _wrap_Dwg_OCD_Dimension_text_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_text_rotation_get", _wrap_Dwg_OCD_Dimension_text_rotation_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_block_set", _wrap_Dwg_OCD_Dimension_block_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_block_get", _wrap_Dwg_OCD_Dimension_block_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_dimtofl_set", _wrap_Dwg_OCD_Dimension_dimtofl_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_dimtofl_get", _wrap_Dwg_OCD_Dimension_dimtofl_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_dimosxd_set", _wrap_Dwg_OCD_Dimension_dimosxd_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_dimosxd_get", _wrap_Dwg_OCD_Dimension_dimosxd_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_dimatfit_set", _wrap_Dwg_OCD_Dimension_dimatfit_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_dimatfit_get", _wrap_Dwg_OCD_Dimension_dimatfit_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_dimtix_set", _wrap_Dwg_OCD_Dimension_dimtix_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_dimtix_get", _wrap_Dwg_OCD_Dimension_dimtix_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_dimtmove_set", _wrap_Dwg_OCD_Dimension_dimtmove_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_dimtmove_get", _wrap_Dwg_OCD_Dimension_dimtmove_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_override_code_set", _wrap_Dwg_OCD_Dimension_override_code_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_override_code_get", _wrap_Dwg_OCD_Dimension_override_code_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_has_arrow2_set", _wrap_Dwg_OCD_Dimension_has_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_has_arrow2_get", _wrap_Dwg_OCD_Dimension_has_arrow2_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_flip_arrow2_set", _wrap_Dwg_OCD_Dimension_flip_arrow2_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_flip_arrow2_get", _wrap_Dwg_OCD_Dimension_flip_arrow2_get, METH_O, NULL},
	 { "Dwg_OCD_Dimension_flip_arrow1_set", _wrap_Dwg_OCD_Dimension_flip_arrow1_set, METH_VARARGS, NULL},
	 { "Dwg_OCD_Dimension_flip_arrow1_get", _wrap_Dwg_OCD_Dimension_flip_arrow1_get, METH_O, NULL},
	 { "new_Dwg_OCD_Dimension", _wrap_new_Dwg_OCD_Dimension, METH_NOARGS, NULL},
	 { "delete_Dwg_OCD_Dimension", _wrap_delete_Dwg_OCD_Dimension, METH_O, NULL},
	 { "Dwg_OCD_Dimension_swigregister", Dwg_OCD_Dimension_swigregister, METH_O, NULL},
	 { "Dwg_OCD_Dimension_swiginit", Dwg_OCD_Dimension_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_get", _wrap_Dwg_Object_ALDIMOBJECTCONTEXTDATA_dimline_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_ALDIMOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_ALDIMOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ALDIMOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_ALDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_swigregister", Dwg_Object_ALDIMOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_ALDIMOBJECTCONTEXTDATA_swiginit", Dwg_Object_ALDIMOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_get", _wrap_Dwg_Object_ANGDIMOBJECTCONTEXTDATA_arc_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_ANGDIMOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_ANGDIMOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ANGDIMOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_ANGDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swigregister", Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swiginit", Dwg_Object_ANGDIMOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_first_arc_pt_get, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_get", _wrap_Dwg_Object_DMDIMOBJECTCONTEXTDATA_def_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_DMDIMOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_DMDIMOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DMDIMOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_DMDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_swigregister", Dwg_Object_DMDIMOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_DMDIMOBJECTCONTEXTDATA_swiginit", Dwg_Object_DMDIMOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_feature_location_pt_get, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_get", _wrap_Dwg_Object_ORDDIMOBJECTCONTEXTDATA_leader_endpt_get, METH_O, NULL},
	 { "new_Dwg_Object_ORDDIMOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_ORDDIMOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ORDDIMOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_ORDDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swigregister", Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swiginit", Dwg_Object_ORDDIMOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_get", _wrap_Dwg_Object_RADIMOBJECTCONTEXTDATA_first_arc_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_RADIMOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_RADIMOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RADIMOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_RADIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_swigregister", Dwg_Object_RADIMOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_RADIMOBJECTCONTEXTDATA_swiginit", Dwg_Object_RADIMOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_dimension_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_ovr_center_get, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_set, METH_VARARGS, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_get", _wrap_Dwg_Object_RADIMLGOBJECTCONTEXTDATA_jog_point_get, METH_O, NULL},
	 { "new_Dwg_Object_RADIMLGOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_RADIMLGOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_RADIMLGOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_RADIMLGOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swigregister", Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swiginit", Dwg_Object_RADIMLGOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_horizontal_mode_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_rotation_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_ins_pt_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_alignment_pt_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_enable_context_get, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_get", _wrap_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_context_get, METH_O, NULL},
	 { "new_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swigregister", Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swiginit", Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_MLEADEROBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "new_Dwg_Object_MLEADEROBJECTCONTEXTDATA", _wrap_new_Dwg_Object_MLEADEROBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_MLEADEROBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_MLEADEROBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_swigregister", Dwg_Object_MLEADEROBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_MLEADEROBJECTCONTEXTDATA_swiginit", Dwg_Object_MLEADEROBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_num_points_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_points_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_points_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_points_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_b290_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_x_direction_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_inspt_offset_get, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_get", _wrap_Dwg_Object_LEADEROBJECTCONTEXTDATA_endptproj_get, METH_O, NULL},
	 { "new_Dwg_Object_LEADEROBJECTCONTEXTDATA", _wrap_new_Dwg_Object_LEADEROBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LEADEROBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_LEADEROBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_swigregister", Dwg_Object_LEADEROBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_LEADEROBJECTCONTEXTDATA_swiginit", Dwg_Object_LEADEROBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_rotation_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_ins_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_get", _wrap_Dwg_Object_BLKREFOBJECTCONTEXTDATA_scale_factor_get, METH_O, NULL},
	 { "new_Dwg_Object_BLKREFOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_BLKREFOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLKREFOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_BLKREFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_swigregister", Dwg_Object_BLKREFOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLKREFOBJECTCONTEXTDATA_swiginit", Dwg_Object_BLKREFOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_parent_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_class_version_get, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_is_default_get, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_scale_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_scale_get, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_location_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_location_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_location_get, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_get", _wrap_Dwg_Object_FCFOBJECTCONTEXTDATA_horiz_dir_get, METH_O, NULL},
	 { "new_Dwg_Object_FCFOBJECTCONTEXTDATA", _wrap_new_Dwg_Object_FCFOBJECTCONTEXTDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_FCFOBJECTCONTEXTDATA", _wrap_delete_Dwg_Object_FCFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_swigregister", Dwg_Object_FCFOBJECTCONTEXTDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_FCFOBJECTCONTEXTDATA_swiginit", Dwg_Object_FCFOBJECTCONTEXTDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_parent_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_parent_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_mdoc_class_version_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_desc_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_desc_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_desc_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_is_modified_for_recompute_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_display_name_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_display_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_display_name_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_display_name_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewstyle_flags_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_class_version_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_class_version_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_flags_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_flags_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_flags_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_style_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_style_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_style_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_height_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_height_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_height_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_exclude_characters_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_offset_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_offset_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_placement_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_identifier_placement_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_identifier_placement_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_arrow_symbol_size_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_ltype_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_linewt_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_boundary_line_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_style_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_text_height_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_attachment_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_offset_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_alignment_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_viewlabel_pattern_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_ltype_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_ltype_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_linewt_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_linewt_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_connection_line_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_connection_line_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_ltype_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_linewt_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_color_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_borderline_color_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_borderline_color_get, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_model_edge_set", _wrap_Dwg_Object_DETAILVIEWSTYLE_model_edge_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_model_edge_get", _wrap_Dwg_Object_DETAILVIEWSTYLE_model_edge_get, METH_O, NULL},
	 { "new_Dwg_Object_DETAILVIEWSTYLE", _wrap_new_Dwg_Object_DETAILVIEWSTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DETAILVIEWSTYLE", _wrap_delete_Dwg_Object_DETAILVIEWSTYLE, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_swigregister", Dwg_Object_DETAILVIEWSTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_DETAILVIEWSTYLE_swiginit", Dwg_Object_DETAILVIEWSTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_parent_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_parent_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_parent_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_mdoc_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_desc_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_desc_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_desc_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_is_modified_for_recompute_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_display_name_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_display_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_display_name_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_display_name_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewstyle_flags_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_class_version_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_class_version_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_class_version_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_flags_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_flags_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_flags_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_style_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_style_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_height_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_height_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_start_symbol_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_end_symbol_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_size_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_exclude_characters_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_position_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_position_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_position_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_identifier_offset_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_position_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_position_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_position_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_arrow_symbol_extension_length_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_ltype_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_linewt_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_plane_line_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_ltype_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_linewt_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_bend_line_length_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_overshoot_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_length_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_end_line_length_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_end_line_length_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_style_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_text_height_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_attachment_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_offset_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_alignment_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_viewlabel_pattern_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_bg_color_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_pattern_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_scale_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_transparency_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b1_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_unknown_b2_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_num_hatch_angles_get, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_get", _wrap_Dwg_Object_SECTIONVIEWSTYLE_hatch_angles_get, METH_O, NULL},
	 { "new_Dwg_Object_SECTIONVIEWSTYLE", _wrap_new_Dwg_Object_SECTIONVIEWSTYLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SECTIONVIEWSTYLE", _wrap_delete_Dwg_Object_SECTIONVIEWSTYLE, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_swigregister", Dwg_Object_SECTIONVIEWSTYLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_SECTIONVIEWSTYLE_swiginit", Dwg_Object_SECTIONVIEWSTYLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_MANAGER_parent_set", _wrap_Dwg_Object_SECTION_MANAGER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_MANAGER_parent_get", _wrap_Dwg_Object_SECTION_MANAGER_parent_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_MANAGER_is_live_set", _wrap_Dwg_Object_SECTION_MANAGER_is_live_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_MANAGER_is_live_get", _wrap_Dwg_Object_SECTION_MANAGER_is_live_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_MANAGER_num_sections_set", _wrap_Dwg_Object_SECTION_MANAGER_num_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_MANAGER_num_sections_get", _wrap_Dwg_Object_SECTION_MANAGER_num_sections_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_MANAGER_sections_set", _wrap_Dwg_Object_SECTION_MANAGER_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_MANAGER_sections_get", _wrap_Dwg_Object_SECTION_MANAGER_sections_get, METH_O, NULL},
	 { "new_Dwg_Object_SECTION_MANAGER", _wrap_new_Dwg_Object_SECTION_MANAGER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SECTION_MANAGER", _wrap_delete_Dwg_Object_SECTION_MANAGER, METH_O, NULL},
	 { "Dwg_Object_SECTION_MANAGER_swigregister", Dwg_Object_SECTION_MANAGER_swigregister, METH_O, NULL},
	 { "Dwg_Object_SECTION_MANAGER_swiginit", Dwg_Object_SECTION_MANAGER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_parent_set", _wrap_Dwg_SECTION_geometrysettings_parent_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_parent_get", _wrap_Dwg_SECTION_geometrysettings_parent_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_num_geoms_set", _wrap_Dwg_SECTION_geometrysettings_num_geoms_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_num_geoms_get", _wrap_Dwg_SECTION_geometrysettings_num_geoms_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hexindex_set", _wrap_Dwg_SECTION_geometrysettings_hexindex_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hexindex_get", _wrap_Dwg_SECTION_geometrysettings_hexindex_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_flags_set", _wrap_Dwg_SECTION_geometrysettings_flags_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_flags_get", _wrap_Dwg_SECTION_geometrysettings_flags_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_color_set", _wrap_Dwg_SECTION_geometrysettings_color_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_color_get", _wrap_Dwg_SECTION_geometrysettings_color_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_layer_set", _wrap_Dwg_SECTION_geometrysettings_layer_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_layer_get", _wrap_Dwg_SECTION_geometrysettings_layer_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_ltype_set", _wrap_Dwg_SECTION_geometrysettings_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_ltype_get", _wrap_Dwg_SECTION_geometrysettings_ltype_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_ltype_scale_set", _wrap_Dwg_SECTION_geometrysettings_ltype_scale_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_ltype_scale_get", _wrap_Dwg_SECTION_geometrysettings_ltype_scale_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_plotstyle_set", _wrap_Dwg_SECTION_geometrysettings_plotstyle_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_plotstyle_get", _wrap_Dwg_SECTION_geometrysettings_plotstyle_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_linewt_set", _wrap_Dwg_SECTION_geometrysettings_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_linewt_get", _wrap_Dwg_SECTION_geometrysettings_linewt_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_face_transparency_set", _wrap_Dwg_SECTION_geometrysettings_face_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_face_transparency_get", _wrap_Dwg_SECTION_geometrysettings_face_transparency_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_edge_transparency_set", _wrap_Dwg_SECTION_geometrysettings_edge_transparency_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_edge_transparency_get", _wrap_Dwg_SECTION_geometrysettings_edge_transparency_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_type_set", _wrap_Dwg_SECTION_geometrysettings_hatch_type_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_type_get", _wrap_Dwg_SECTION_geometrysettings_hatch_type_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_pattern_set", _wrap_Dwg_SECTION_geometrysettings_hatch_pattern_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_pattern_get", _wrap_Dwg_SECTION_geometrysettings_hatch_pattern_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_angle_set", _wrap_Dwg_SECTION_geometrysettings_hatch_angle_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_angle_get", _wrap_Dwg_SECTION_geometrysettings_hatch_angle_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_spacing_set", _wrap_Dwg_SECTION_geometrysettings_hatch_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_spacing_get", _wrap_Dwg_SECTION_geometrysettings_hatch_spacing_get, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_scale_set", _wrap_Dwg_SECTION_geometrysettings_hatch_scale_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_geometrysettings_hatch_scale_get", _wrap_Dwg_SECTION_geometrysettings_hatch_scale_get, METH_O, NULL},
	 { "new_Dwg_SECTION_geometrysettings", _wrap_new_Dwg_SECTION_geometrysettings, METH_NOARGS, NULL},
	 { "delete_Dwg_SECTION_geometrysettings", _wrap_delete_Dwg_SECTION_geometrysettings, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_swigregister", Dwg_SECTION_geometrysettings_swigregister, METH_O, NULL},
	 { "Dwg_SECTION_geometrysettings_swiginit", Dwg_SECTION_geometrysettings_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_parent_set", _wrap_Dwg_SECTION_typesettings_parent_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_parent_get", _wrap_Dwg_SECTION_typesettings_parent_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_type_set", _wrap_Dwg_SECTION_typesettings_type_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_type_get", _wrap_Dwg_SECTION_typesettings_type_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_generation_set", _wrap_Dwg_SECTION_typesettings_generation_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_generation_get", _wrap_Dwg_SECTION_typesettings_generation_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_num_sources_set", _wrap_Dwg_SECTION_typesettings_num_sources_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_num_sources_get", _wrap_Dwg_SECTION_typesettings_num_sources_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_sources_set", _wrap_Dwg_SECTION_typesettings_sources_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_sources_get", _wrap_Dwg_SECTION_typesettings_sources_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_destblock_set", _wrap_Dwg_SECTION_typesettings_destblock_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_destblock_get", _wrap_Dwg_SECTION_typesettings_destblock_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_destfile_set", _wrap_Dwg_SECTION_typesettings_destfile_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_destfile_get", _wrap_Dwg_SECTION_typesettings_destfile_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_num_geom_set", _wrap_Dwg_SECTION_typesettings_num_geom_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_num_geom_get", _wrap_Dwg_SECTION_typesettings_num_geom_get, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_geom_set", _wrap_Dwg_SECTION_typesettings_geom_set, METH_VARARGS, NULL},
	 { "Dwg_SECTION_typesettings_geom_get", _wrap_Dwg_SECTION_typesettings_geom_get, METH_O, NULL},
	 { "new_Dwg_SECTION_typesettings", _wrap_new_Dwg_SECTION_typesettings, METH_NOARGS, NULL},
	 { "delete_Dwg_SECTION_typesettings", _wrap_delete_Dwg_SECTION_typesettings, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_swigregister", Dwg_SECTION_typesettings_swigregister, METH_O, NULL},
	 { "Dwg_SECTION_typesettings_swiginit", Dwg_SECTION_typesettings_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_parent_set", _wrap_Dwg_Object_SECTION_SETTINGS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_parent_get", _wrap_Dwg_Object_SECTION_SETTINGS_parent_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_curr_type_set", _wrap_Dwg_Object_SECTION_SETTINGS_curr_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_curr_type_get", _wrap_Dwg_Object_SECTION_SETTINGS_curr_type_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_num_types_set", _wrap_Dwg_Object_SECTION_SETTINGS_num_types_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_num_types_get", _wrap_Dwg_Object_SECTION_SETTINGS_num_types_get, METH_O, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_types_set", _wrap_Dwg_Object_SECTION_SETTINGS_types_set, METH_VARARGS, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_types_get", _wrap_Dwg_Object_SECTION_SETTINGS_types_get, METH_O, NULL},
	 { "new_Dwg_Object_SECTION_SETTINGS", _wrap_new_Dwg_Object_SECTION_SETTINGS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_SECTION_SETTINGS", _wrap_delete_Dwg_Object_SECTION_SETTINGS, METH_O, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_swigregister", Dwg_Object_SECTION_SETTINGS_swigregister, METH_O, NULL},
	 { "Dwg_Object_SECTION_SETTINGS_swiginit", Dwg_Object_SECTION_SETTINGS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYERFILTER_parent_set", _wrap_Dwg_Object_LAYERFILTER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYERFILTER_parent_get", _wrap_Dwg_Object_LAYERFILTER_parent_get, METH_O, NULL},
	 { "Dwg_Object_LAYERFILTER_num_names_set", _wrap_Dwg_Object_LAYERFILTER_num_names_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYERFILTER_num_names_get", _wrap_Dwg_Object_LAYERFILTER_num_names_get, METH_O, NULL},
	 { "Dwg_Object_LAYERFILTER_names_set", _wrap_Dwg_Object_LAYERFILTER_names_set, METH_VARARGS, NULL},
	 { "Dwg_Object_LAYERFILTER_names_get", _wrap_Dwg_Object_LAYERFILTER_names_get, METH_O, NULL},
	 { "new_Dwg_Object_LAYERFILTER", _wrap_new_Dwg_Object_LAYERFILTER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_LAYERFILTER", _wrap_delete_Dwg_Object_LAYERFILTER, METH_O, NULL},
	 { "Dwg_Object_LAYERFILTER_swigregister", Dwg_Object_LAYERFILTER_swigregister, METH_O, NULL},
	 { "Dwg_Object_LAYERFILTER_swiginit", Dwg_Object_LAYERFILTER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_parent_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_parent_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_size_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_size_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_size_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_size_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_xscale_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_xscale_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_xscale_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_xscale_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_char_spacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_char_spacing_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_char_spacing_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_style_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_style_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_style_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_value_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_value_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_value_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_font_name_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_font_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_font_name_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_font_name_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_bigfont_name_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_offset_from_arc_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_right_offset_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_right_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_right_offset_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_right_offset_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_left_offset_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_left_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_left_offset_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_left_offset_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_center_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_center_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_center_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_center_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_radius_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_radius_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_radius_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_radius_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_start_angle_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_start_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_start_angle_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_start_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_end_angle_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_end_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_end_angle_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_end_angle_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_extrusion_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_extrusion_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_color_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_color_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_color_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_color_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_reverse_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_reverse_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_reverse_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_direction_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_direction_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_direction_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_direction_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_alignment_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_alignment_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_alignment_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_alignment_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_position_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_position_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_text_position_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_text_position_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_bold_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_bold_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_bold_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_bold_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_italic_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_italic_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_italic_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_italic_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_underlined_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_underlined_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_underlined_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_character_set_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_character_set_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_character_set_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_character_set_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_pitch_and_family_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_shx_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_shx_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_is_shx_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_is_shx_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_wizard_flag_get, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set", _wrap_Dwg_Entity_ARCALIGNEDTEXT_arc_handle_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_arc_handle_get", _wrap_Dwg_Entity_ARCALIGNEDTEXT_arc_handle_get, METH_O, NULL},
	 { "new_Dwg_Entity_ARCALIGNEDTEXT", _wrap_new_Dwg_Entity_ARCALIGNEDTEXT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ARCALIGNEDTEXT", _wrap_delete_Dwg_Entity_ARCALIGNEDTEXT, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_swigregister", Dwg_Entity_ARCALIGNEDTEXT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ARCALIGNEDTEXT_swiginit", Dwg_Entity_ARCALIGNEDTEXT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_parent_set", _wrap_Dwg_Entity_RTEXT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_parent_get", _wrap_Dwg_Entity_RTEXT_parent_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_pt_set", _wrap_Dwg_Entity_RTEXT_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_pt_get", _wrap_Dwg_Entity_RTEXT_pt_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_extrusion_set", _wrap_Dwg_Entity_RTEXT_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_extrusion_get", _wrap_Dwg_Entity_RTEXT_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_rotation_set", _wrap_Dwg_Entity_RTEXT_rotation_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_rotation_get", _wrap_Dwg_Entity_RTEXT_rotation_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_height_set", _wrap_Dwg_Entity_RTEXT_height_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_height_get", _wrap_Dwg_Entity_RTEXT_height_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_flags_set", _wrap_Dwg_Entity_RTEXT_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_flags_get", _wrap_Dwg_Entity_RTEXT_flags_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_text_value_set", _wrap_Dwg_Entity_RTEXT_text_value_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_text_value_get", _wrap_Dwg_Entity_RTEXT_text_value_get, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_style_set", _wrap_Dwg_Entity_RTEXT_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_RTEXT_style_get", _wrap_Dwg_Entity_RTEXT_style_get, METH_O, NULL},
	 { "new_Dwg_Entity_RTEXT", _wrap_new_Dwg_Entity_RTEXT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_RTEXT", _wrap_delete_Dwg_Entity_RTEXT, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_swigregister", Dwg_Entity_RTEXT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_RTEXT_swiginit", Dwg_Entity_RTEXT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_parent_set", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_parent_get", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_class_version_get", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_flag_set", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_flag_get", _wrap_Dwg_Entity_LAYOUTPRINTCONFIG_flag_get, METH_O, NULL},
	 { "new_Dwg_Entity_LAYOUTPRINTCONFIG", _wrap_new_Dwg_Entity_LAYOUTPRINTCONFIG, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LAYOUTPRINTCONFIG", _wrap_delete_Dwg_Entity_LAYOUTPRINTCONFIG, METH_O, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_swigregister", Dwg_Entity_LAYOUTPRINTCONFIG_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LAYOUTPRINTCONFIG_swiginit", Dwg_Entity_LAYOUTPRINTCONFIG_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_parent_set", _wrap_Dwg_Object_ACMECOMMANDHISTORY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_parent_get", _wrap_Dwg_Object_ACMECOMMANDHISTORY_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_class_version_set", _wrap_Dwg_Object_ACMECOMMANDHISTORY_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_class_version_get", _wrap_Dwg_Object_ACMECOMMANDHISTORY_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ACMECOMMANDHISTORY", _wrap_new_Dwg_Object_ACMECOMMANDHISTORY, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACMECOMMANDHISTORY", _wrap_delete_Dwg_Object_ACMECOMMANDHISTORY, METH_O, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_swigregister", Dwg_Object_ACMECOMMANDHISTORY_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACMECOMMANDHISTORY_swiginit", Dwg_Object_ACMECOMMANDHISTORY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESCOPE_parent_set", _wrap_Dwg_Object_ACMESCOPE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESCOPE_parent_get", _wrap_Dwg_Object_ACMESCOPE_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACMESCOPE_class_version_set", _wrap_Dwg_Object_ACMESCOPE_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESCOPE_class_version_get", _wrap_Dwg_Object_ACMESCOPE_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ACMESCOPE", _wrap_new_Dwg_Object_ACMESCOPE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACMESCOPE", _wrap_delete_Dwg_Object_ACMESCOPE, METH_O, NULL},
	 { "Dwg_Object_ACMESCOPE_swigregister", Dwg_Object_ACMESCOPE_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACMESCOPE_swiginit", Dwg_Object_ACMESCOPE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESTATEMGR_parent_set", _wrap_Dwg_Object_ACMESTATEMGR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESTATEMGR_parent_get", _wrap_Dwg_Object_ACMESTATEMGR_parent_get, METH_O, NULL},
	 { "Dwg_Object_ACMESTATEMGR_class_version_set", _wrap_Dwg_Object_ACMESTATEMGR_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_ACMESTATEMGR_class_version_get", _wrap_Dwg_Object_ACMESTATEMGR_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_ACMESTATEMGR", _wrap_new_Dwg_Object_ACMESTATEMGR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_ACMESTATEMGR", _wrap_delete_Dwg_Object_ACMESTATEMGR, METH_O, NULL},
	 { "Dwg_Object_ACMESTATEMGR_swigregister", Dwg_Object_ACMESTATEMGR_swigregister, METH_O, NULL},
	 { "Dwg_Object_ACMESTATEMGR_swiginit", Dwg_Object_ACMESTATEMGR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_parent_set", _wrap_Dwg_Object_CSACDOCUMENTOPTIONS_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_parent_get", _wrap_Dwg_Object_CSACDOCUMENTOPTIONS_parent_get, METH_O, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set", _wrap_Dwg_Object_CSACDOCUMENTOPTIONS_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_class_version_get", _wrap_Dwg_Object_CSACDOCUMENTOPTIONS_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_CSACDOCUMENTOPTIONS", _wrap_new_Dwg_Object_CSACDOCUMENTOPTIONS, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_CSACDOCUMENTOPTIONS", _wrap_delete_Dwg_Object_CSACDOCUMENTOPTIONS, METH_O, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_swigregister", Dwg_Object_CSACDOCUMENTOPTIONS_swigregister, METH_O, NULL},
	 { "Dwg_Object_CSACDOCUMENTOPTIONS_swiginit", Dwg_Object_CSACDOCUMENTOPTIONS_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_code_set", _wrap_Dwg_BLOCKPARAMETER_connection_code_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_code_get", _wrap_Dwg_BLOCKPARAMETER_connection_code_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_name_set", _wrap_Dwg_BLOCKPARAMETER_connection_name_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_name_get", _wrap_Dwg_BLOCKPARAMETER_connection_name_get, METH_O, NULL},
	 { "new_Dwg_BLOCKPARAMETER_connection", _wrap_new_Dwg_BLOCKPARAMETER_connection, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKPARAMETER_connection", _wrap_delete_Dwg_BLOCKPARAMETER_connection, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_swigregister", Dwg_BLOCKPARAMETER_connection_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_connection_swiginit", Dwg_BLOCKPARAMETER_connection_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_num_connections_set", _wrap_Dwg_BLOCKPARAMETER_PropInfo_num_connections_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_num_connections_get", _wrap_Dwg_BLOCKPARAMETER_PropInfo_num_connections_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_connections_set", _wrap_Dwg_BLOCKPARAMETER_PropInfo_connections_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_connections_get", _wrap_Dwg_BLOCKPARAMETER_PropInfo_connections_get, METH_O, NULL},
	 { "new_Dwg_BLOCKPARAMETER_PropInfo", _wrap_new_Dwg_BLOCKPARAMETER_PropInfo, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKPARAMETER_PropInfo", _wrap_delete_Dwg_BLOCKPARAMETER_PropInfo, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_swigregister", Dwg_BLOCKPARAMETER_PropInfo_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKPARAMETER_PropInfo_swiginit", Dwg_BLOCKPARAMETER_PropInfo_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_desc_set", _wrap_Dwg_BLOCKPARAMVALUESET_desc_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_desc_get", _wrap_Dwg_BLOCKPARAMVALUESET_desc_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_flags_set", _wrap_Dwg_BLOCKPARAMVALUESET_flags_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_flags_get", _wrap_Dwg_BLOCKPARAMVALUESET_flags_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_minimum_set", _wrap_Dwg_BLOCKPARAMVALUESET_minimum_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_minimum_get", _wrap_Dwg_BLOCKPARAMVALUESET_minimum_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_maximum_set", _wrap_Dwg_BLOCKPARAMVALUESET_maximum_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_maximum_get", _wrap_Dwg_BLOCKPARAMVALUESET_maximum_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_increment_set", _wrap_Dwg_BLOCKPARAMVALUESET_increment_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_increment_get", _wrap_Dwg_BLOCKPARAMVALUESET_increment_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_num_valuelist_set", _wrap_Dwg_BLOCKPARAMVALUESET_num_valuelist_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_num_valuelist_get", _wrap_Dwg_BLOCKPARAMVALUESET_num_valuelist_get, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_valuelist_set", _wrap_Dwg_BLOCKPARAMVALUESET_valuelist_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_valuelist_get", _wrap_Dwg_BLOCKPARAMVALUESET_valuelist_get, METH_O, NULL},
	 { "new_Dwg_BLOCKPARAMVALUESET", _wrap_new_Dwg_BLOCKPARAMVALUESET, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKPARAMVALUESET", _wrap_delete_Dwg_BLOCKPARAMVALUESET, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_swigregister", Dwg_BLOCKPARAMVALUESET_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKPARAMVALUESET_swiginit", Dwg_BLOCKPARAMVALUESET_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_code_set", _wrap_Dwg_BLOCKACTION_connectionpts_code_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_code_get", _wrap_Dwg_BLOCKACTION_connectionpts_code_get, METH_O, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_name_set", _wrap_Dwg_BLOCKACTION_connectionpts_name_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_name_get", _wrap_Dwg_BLOCKACTION_connectionpts_name_get, METH_O, NULL},
	 { "new_Dwg_BLOCKACTION_connectionpts", _wrap_new_Dwg_BLOCKACTION_connectionpts, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKACTION_connectionpts", _wrap_delete_Dwg_BLOCKACTION_connectionpts, METH_O, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_swigregister", Dwg_BLOCKACTION_connectionpts_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKACTION_connectionpts_swiginit", Dwg_BLOCKACTION_connectionpts_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_parent_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_parent_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_parent_get, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_name_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_name_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_name_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_name_get, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_blocks_get, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_blocks_get, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_num_params_get, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_params_set", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_params_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_params_get", _wrap_Dwg_BLOCKVISIBILITYPARAMETER_state_params_get, METH_O, NULL},
	 { "new_Dwg_BLOCKVISIBILITYPARAMETER_state", _wrap_new_Dwg_BLOCKVISIBILITYPARAMETER_state, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKVISIBILITYPARAMETER_state", _wrap_delete_Dwg_BLOCKVISIBILITYPARAMETER_state, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_swigregister", Dwg_BLOCKVISIBILITYPARAMETER_state_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKVISIBILITYPARAMETER_state_swiginit", Dwg_BLOCKVISIBILITYPARAMETER_state_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_name_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_propinfos_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_is_initialized_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_unknown_bool_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blockvisi_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_blocks_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_blocks_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_num_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_states_get", _wrap_Dwg_Object_BLOCKVISIBILITYPARAMETER_states_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKVISIBILITYPARAMETER", _wrap_new_Dwg_Object_BLOCKVISIBILITYPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKVISIBILITYPARAMETER", _wrap_delete_Dwg_Object_BLOCKVISIBILITYPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_swigregister", Dwg_Object_BLOCKVISIBILITYPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYPARAMETER_swiginit", Dwg_Object_BLOCKVISIBILITYPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_parent_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_parent_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_name_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_name_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_be_major_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKVISIBILITYGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKVISIBILITYGRIP", _wrap_new_Dwg_Object_BLOCKVISIBILITYGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKVISIBILITYGRIP", _wrap_delete_Dwg_Object_BLOCKVISIBILITYGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_swigregister", Dwg_Object_BLOCKVISIBILITYGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKVISIBILITYGRIP_swiginit", Dwg_Object_BLOCKVISIBILITYGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_get", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_get", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_get", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_type_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_get", _wrap_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_grip_expr_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT", _wrap_new_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT", _wrap_delete_Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT, METH_O, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swigregister", Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swiginit", Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKDATA_parent_set", _wrap_Dwg_Object_BREAKDATA_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKDATA_parent_get", _wrap_Dwg_Object_BREAKDATA_parent_get, METH_O, NULL},
	 { "Dwg_Object_BREAKDATA_num_pointrefs_set", _wrap_Dwg_Object_BREAKDATA_num_pointrefs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKDATA_num_pointrefs_get", _wrap_Dwg_Object_BREAKDATA_num_pointrefs_get, METH_O, NULL},
	 { "Dwg_Object_BREAKDATA_pointrefs_set", _wrap_Dwg_Object_BREAKDATA_pointrefs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKDATA_pointrefs_get", _wrap_Dwg_Object_BREAKDATA_pointrefs_get, METH_O, NULL},
	 { "Dwg_Object_BREAKDATA_dimref_set", _wrap_Dwg_Object_BREAKDATA_dimref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKDATA_dimref_get", _wrap_Dwg_Object_BREAKDATA_dimref_get, METH_O, NULL},
	 { "new_Dwg_Object_BREAKDATA", _wrap_new_Dwg_Object_BREAKDATA, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BREAKDATA", _wrap_delete_Dwg_Object_BREAKDATA, METH_O, NULL},
	 { "Dwg_Object_BREAKDATA_swigregister", Dwg_Object_BREAKDATA_swigregister, METH_O, NULL},
	 { "Dwg_Object_BREAKDATA_swiginit", Dwg_Object_BREAKDATA_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKPOINTREF_parent_set", _wrap_Dwg_Object_BREAKPOINTREF_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BREAKPOINTREF_parent_get", _wrap_Dwg_Object_BREAKPOINTREF_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_BREAKPOINTREF", _wrap_new_Dwg_Object_BREAKPOINTREF, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BREAKPOINTREF", _wrap_delete_Dwg_Object_BREAKPOINTREF, METH_O, NULL},
	 { "Dwg_Object_BREAKPOINTREF_swigregister", Dwg_Object_BREAKPOINTREF_swigregister, METH_O, NULL},
	 { "Dwg_Object_BREAKPOINTREF_swiginit", Dwg_Object_BREAKPOINTREF_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_FLIPGRIPENTITY_parent_set", _wrap_Dwg_Entity_FLIPGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_FLIPGRIPENTITY_parent_get", _wrap_Dwg_Entity_FLIPGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_FLIPGRIPENTITY", _wrap_new_Dwg_Entity_FLIPGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_FLIPGRIPENTITY", _wrap_delete_Dwg_Entity_FLIPGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_FLIPGRIPENTITY_swigregister", Dwg_Entity_FLIPGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_FLIPGRIPENTITY_swiginit", Dwg_Entity_FLIPGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINEARGRIPENTITY_parent_set", _wrap_Dwg_Entity_LINEARGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINEARGRIPENTITY_parent_get", _wrap_Dwg_Entity_LINEARGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_LINEARGRIPENTITY", _wrap_new_Dwg_Entity_LINEARGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LINEARGRIPENTITY", _wrap_delete_Dwg_Entity_LINEARGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_LINEARGRIPENTITY_swigregister", Dwg_Entity_LINEARGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LINEARGRIPENTITY_swiginit", Dwg_Entity_LINEARGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLARGRIPENTITY_parent_set", _wrap_Dwg_Entity_POLARGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POLARGRIPENTITY_parent_get", _wrap_Dwg_Entity_POLARGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_POLARGRIPENTITY", _wrap_new_Dwg_Entity_POLARGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POLARGRIPENTITY", _wrap_delete_Dwg_Entity_POLARGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_POLARGRIPENTITY_swigregister", Dwg_Entity_POLARGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POLARGRIPENTITY_swiginit", Dwg_Entity_POLARGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ROTATIONGRIPENTITY_parent_set", _wrap_Dwg_Entity_ROTATIONGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ROTATIONGRIPENTITY_parent_get", _wrap_Dwg_Entity_ROTATIONGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_ROTATIONGRIPENTITY", _wrap_new_Dwg_Entity_ROTATIONGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ROTATIONGRIPENTITY", _wrap_delete_Dwg_Entity_ROTATIONGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_ROTATIONGRIPENTITY_swigregister", Dwg_Entity_ROTATIONGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ROTATIONGRIPENTITY_swiginit", Dwg_Entity_ROTATIONGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VISIBILITYGRIPENTITY_parent_set", _wrap_Dwg_Entity_VISIBILITYGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VISIBILITYGRIPENTITY_parent_get", _wrap_Dwg_Entity_VISIBILITYGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_VISIBILITYGRIPENTITY", _wrap_new_Dwg_Entity_VISIBILITYGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VISIBILITYGRIPENTITY", _wrap_delete_Dwg_Entity_VISIBILITYGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_VISIBILITYGRIPENTITY_swigregister", Dwg_Entity_VISIBILITYGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VISIBILITYGRIPENTITY_swiginit", Dwg_Entity_VISIBILITYGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_XYGRIPENTITY_parent_set", _wrap_Dwg_Entity_XYGRIPENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_XYGRIPENTITY_parent_get", _wrap_Dwg_Entity_XYGRIPENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_XYGRIPENTITY", _wrap_new_Dwg_Entity_XYGRIPENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_XYGRIPENTITY", _wrap_delete_Dwg_Entity_XYGRIPENTITY, METH_O, NULL},
	 { "Dwg_Entity_XYGRIPENTITY_swigregister", Dwg_Entity_XYGRIPENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_XYGRIPENTITY_swiginit", Dwg_Entity_XYGRIPENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_ALIGNMENTPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_ALIGNMENTPARAMETERENTITY", _wrap_new_Dwg_Entity_ALIGNMENTPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ALIGNMENTPARAMETERENTITY", _wrap_delete_Dwg_Entity_ALIGNMENTPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_ALIGNMENTPARAMETERENTITY_swigregister", Dwg_Entity_ALIGNMENTPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ALIGNMENTPARAMETERENTITY_swiginit", Dwg_Entity_ALIGNMENTPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_BASEPOINTPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_BASEPOINTPARAMETERENTITY", _wrap_new_Dwg_Entity_BASEPOINTPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_BASEPOINTPARAMETERENTITY", _wrap_delete_Dwg_Entity_BASEPOINTPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_BASEPOINTPARAMETERENTITY_swigregister", Dwg_Entity_BASEPOINTPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_BASEPOINTPARAMETERENTITY_swiginit", Dwg_Entity_BASEPOINTPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_FLIPPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_FLIPPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_FLIPPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_FLIPPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_FLIPPARAMETERENTITY", _wrap_new_Dwg_Entity_FLIPPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_FLIPPARAMETERENTITY", _wrap_delete_Dwg_Entity_FLIPPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_FLIPPARAMETERENTITY_swigregister", Dwg_Entity_FLIPPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_FLIPPARAMETERENTITY_swiginit", Dwg_Entity_FLIPPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINEARPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_LINEARPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LINEARPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_LINEARPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_LINEARPARAMETERENTITY", _wrap_new_Dwg_Entity_LINEARPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LINEARPARAMETERENTITY", _wrap_delete_Dwg_Entity_LINEARPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_LINEARPARAMETERENTITY_swigregister", Dwg_Entity_LINEARPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LINEARPARAMETERENTITY_swiginit", Dwg_Entity_LINEARPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_POINTPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_POINTPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_POINTPARAMETERENTITY", _wrap_new_Dwg_Entity_POINTPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POINTPARAMETERENTITY", _wrap_delete_Dwg_Entity_POINTPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_POINTPARAMETERENTITY_swigregister", Dwg_Entity_POINTPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POINTPARAMETERENTITY_swiginit", Dwg_Entity_POINTPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_ROTATIONPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ROTATIONPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_ROTATIONPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_ROTATIONPARAMETERENTITY", _wrap_new_Dwg_Entity_ROTATIONPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ROTATIONPARAMETERENTITY", _wrap_delete_Dwg_Entity_ROTATIONPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_ROTATIONPARAMETERENTITY_swigregister", Dwg_Entity_ROTATIONPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ROTATIONPARAMETERENTITY_swiginit", Dwg_Entity_ROTATIONPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_VISIBILITYPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_VISIBILITYPARAMETERENTITY", _wrap_new_Dwg_Entity_VISIBILITYPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_VISIBILITYPARAMETERENTITY", _wrap_delete_Dwg_Entity_VISIBILITYPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_VISIBILITYPARAMETERENTITY_swigregister", Dwg_Entity_VISIBILITYPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_VISIBILITYPARAMETERENTITY_swiginit", Dwg_Entity_VISIBILITYPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_XYPARAMETERENTITY_parent_set", _wrap_Dwg_Entity_XYPARAMETERENTITY_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_XYPARAMETERENTITY_parent_get", _wrap_Dwg_Entity_XYPARAMETERENTITY_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_XYPARAMETERENTITY", _wrap_new_Dwg_Entity_XYPARAMETERENTITY, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_XYPARAMETERENTITY", _wrap_delete_Dwg_Entity_XYPARAMETERENTITY, METH_O, NULL},
	 { "Dwg_Entity_XYPARAMETERENTITY_swigregister", Dwg_Entity_XYPARAMETERENTITY_swigregister, METH_O, NULL},
	 { "Dwg_Entity_XYPARAMETERENTITY_swiginit", Dwg_Entity_XYPARAMETERENTITY_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_parent_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_parent_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_name_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_name_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_be_major_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_orientation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_orientation_get", _wrap_Dwg_Object_BLOCKALIGNMENTGRIP_orientation_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKALIGNMENTGRIP", _wrap_new_Dwg_Object_BLOCKALIGNMENTGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKALIGNMENTGRIP", _wrap_delete_Dwg_Object_BLOCKALIGNMENTGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_swigregister", Dwg_Object_BLOCKALIGNMENTGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTGRIP_swiginit", Dwg_Object_BLOCKALIGNMENTGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_get", _wrap_Dwg_Object_BLOCKALIGNMENTPARAMETER_align_perpendicular_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKALIGNMENTPARAMETER", _wrap_new_Dwg_Object_BLOCKALIGNMENTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKALIGNMENTPARAMETER", _wrap_delete_Dwg_Object_BLOCKALIGNMENTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_swigregister", Dwg_Object_BLOCKALIGNMENTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNMENTPARAMETER_swiginit", Dwg_Object_BLOCKALIGNMENTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_center_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_end_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_angle_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_orientation_on_both_grips_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_distance_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_orientation_on_both_grips_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_distance_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_parent_set", _wrap_Dwg_Object_BLOCKARRAYACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_parent_get", _wrap_Dwg_Object_BLOCKARRAYACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKARRAYACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKARRAYACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_name_set", _wrap_Dwg_Object_BLOCKARRAYACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_name_get", _wrap_Dwg_Object_BLOCKARRAYACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_be_major_set", _wrap_Dwg_Object_BLOCKARRAYACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_be_major_get", _wrap_Dwg_Object_BLOCKARRAYACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_be_minor_set", _wrap_Dwg_Object_BLOCKARRAYACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_be_minor_get", _wrap_Dwg_Object_BLOCKARRAYACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_eed1071_set", _wrap_Dwg_Object_BLOCKARRAYACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_eed1071_get", _wrap_Dwg_Object_BLOCKARRAYACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_display_location_set", _wrap_Dwg_Object_BLOCKARRAYACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_display_location_get", _wrap_Dwg_Object_BLOCKARRAYACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_num_actions_set", _wrap_Dwg_Object_BLOCKARRAYACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_num_actions_get", _wrap_Dwg_Object_BLOCKARRAYACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_actions_set", _wrap_Dwg_Object_BLOCKARRAYACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_actions_get", _wrap_Dwg_Object_BLOCKARRAYACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_num_deps_set", _wrap_Dwg_Object_BLOCKARRAYACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_num_deps_get", _wrap_Dwg_Object_BLOCKARRAYACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_deps_set", _wrap_Dwg_Object_BLOCKARRAYACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_deps_get", _wrap_Dwg_Object_BLOCKARRAYACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKARRAYACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKARRAYACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_column_offset_set", _wrap_Dwg_Object_BLOCKARRAYACTION_column_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_column_offset_get", _wrap_Dwg_Object_BLOCKARRAYACTION_column_offset_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_row_offset_set", _wrap_Dwg_Object_BLOCKARRAYACTION_row_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_row_offset_get", _wrap_Dwg_Object_BLOCKARRAYACTION_row_offset_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKARRAYACTION", _wrap_new_Dwg_Object_BLOCKARRAYACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKARRAYACTION", _wrap_delete_Dwg_Object_BLOCKARRAYACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_swigregister", Dwg_Object_BLOCKARRAYACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKARRAYACTION_swiginit", Dwg_Object_BLOCKARRAYACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_num_propinfos_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_get", _wrap_Dwg_Object_BLOCKBASEPOINTPARAMETER_base_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKBASEPOINTPARAMETER", _wrap_new_Dwg_Object_BLOCKBASEPOINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKBASEPOINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKBASEPOINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_swigregister", Dwg_Object_BLOCKBASEPOINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKBASEPOINTPARAMETER_swiginit", Dwg_Object_BLOCKBASEPOINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_parent_set", _wrap_Dwg_Object_BLOCKFLIPACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_parent_get", _wrap_Dwg_Object_BLOCKFLIPACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKFLIPACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKFLIPACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_name_set", _wrap_Dwg_Object_BLOCKFLIPACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_name_get", _wrap_Dwg_Object_BLOCKFLIPACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_be_major_set", _wrap_Dwg_Object_BLOCKFLIPACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_be_major_get", _wrap_Dwg_Object_BLOCKFLIPACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_be_minor_set", _wrap_Dwg_Object_BLOCKFLIPACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_be_minor_get", _wrap_Dwg_Object_BLOCKFLIPACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_eed1071_set", _wrap_Dwg_Object_BLOCKFLIPACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_eed1071_get", _wrap_Dwg_Object_BLOCKFLIPACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_display_location_set", _wrap_Dwg_Object_BLOCKFLIPACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_display_location_get", _wrap_Dwg_Object_BLOCKFLIPACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_num_actions_set", _wrap_Dwg_Object_BLOCKFLIPACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_num_actions_get", _wrap_Dwg_Object_BLOCKFLIPACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_actions_set", _wrap_Dwg_Object_BLOCKFLIPACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_actions_get", _wrap_Dwg_Object_BLOCKFLIPACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_num_deps_set", _wrap_Dwg_Object_BLOCKFLIPACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_num_deps_get", _wrap_Dwg_Object_BLOCKFLIPACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_deps_set", _wrap_Dwg_Object_BLOCKFLIPACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_deps_get", _wrap_Dwg_Object_BLOCKFLIPACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKFLIPACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKFLIPACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_action_offset_x_set", _wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_x_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_action_offset_x_get", _wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_x_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_action_offset_y_set", _wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_y_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_action_offset_y_get", _wrap_Dwg_Object_BLOCKFLIPACTION_action_offset_y_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_angle_offset_set", _wrap_Dwg_Object_BLOCKFLIPACTION_angle_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_angle_offset_get", _wrap_Dwg_Object_BLOCKFLIPACTION_angle_offset_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKFLIPACTION", _wrap_new_Dwg_Object_BLOCKFLIPACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKFLIPACTION", _wrap_delete_Dwg_Object_BLOCKFLIPACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_swigregister", Dwg_Object_BLOCKFLIPACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPACTION_swiginit", Dwg_Object_BLOCKFLIPACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_parent_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_parent_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_name_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_name_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_be_major_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_be_major_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_combined_state_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_combined_state_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_combined_state_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_combined_state_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_orientation_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_orientation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_orientation_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_orientation_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_upd_state_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_upd_state_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_upd_state_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_upd_state_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_state_set", _wrap_Dwg_Object_BLOCKFLIPGRIP_state_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_state_get", _wrap_Dwg_Object_BLOCKFLIPGRIP_state_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKFLIPGRIP", _wrap_new_Dwg_Object_BLOCKFLIPGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKFLIPGRIP", _wrap_delete_Dwg_Object_BLOCKFLIPGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_swigregister", Dwg_Object_BLOCKFLIPGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPGRIP_swiginit", Dwg_Object_BLOCKFLIPGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_name_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_name_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flip_label_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_base_state_label_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_flipped_state_label_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_def_label_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_bl96_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_bl96_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_bl96_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_bl96_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_tooltip_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_tooltip_get", _wrap_Dwg_Object_BLOCKFLIPPARAMETER_tooltip_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKFLIPPARAMETER", _wrap_new_Dwg_Object_BLOCKFLIPPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKFLIPPARAMETER", _wrap_delete_Dwg_Object_BLOCKFLIPPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_swigregister", Dwg_Object_BLOCKFLIPPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKFLIPPARAMETER_swiginit", Dwg_Object_BLOCKFLIPPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_dependency_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_expr_description_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER", _wrap_new_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swigregister", Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swiginit", Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_parent_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_parent_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_name_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_name_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_be_major_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_be_major_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_orientation_set", _wrap_Dwg_Object_BLOCKLINEARGRIP_orientation_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_orientation_get", _wrap_Dwg_Object_BLOCKLINEARGRIP_orientation_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLINEARGRIP", _wrap_new_Dwg_Object_BLOCKLINEARGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLINEARGRIP", _wrap_delete_Dwg_Object_BLOCKLINEARGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_swigregister", Dwg_Object_BLOCKLINEARGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARGRIP_swiginit", Dwg_Object_BLOCKLINEARGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_name_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_name_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_name_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_distance_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_distance_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_value_set_set", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_value_set_get", _wrap_Dwg_Object_BLOCKLINEARPARAMETER_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLINEARPARAMETER", _wrap_new_Dwg_Object_BLOCKLINEARPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLINEARPARAMETER", _wrap_delete_Dwg_Object_BLOCKLINEARPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_swigregister", Dwg_Object_BLOCKLINEARPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLINEARPARAMETER_swiginit", Dwg_Object_BLOCKLINEARPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_parent_set", _wrap_Dwg_BLOCKLOOKUPACTION_lut_parent_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_parent_get", _wrap_Dwg_BLOCKLOOKUPACTION_lut_parent_get, METH_O, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set", _wrap_Dwg_BLOCKLOOKUPACTION_lut_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_conn_pts_get", _wrap_Dwg_BLOCKLOOKUPACTION_lut_conn_pts_get, METH_O, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_b282_set", _wrap_Dwg_BLOCKLOOKUPACTION_lut_b282_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_b282_get", _wrap_Dwg_BLOCKLOOKUPACTION_lut_b282_get, METH_O, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_b281_set", _wrap_Dwg_BLOCKLOOKUPACTION_lut_b281_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_b281_get", _wrap_Dwg_BLOCKLOOKUPACTION_lut_b281_get, METH_O, NULL},
	 { "new_Dwg_BLOCKLOOKUPACTION_lut", _wrap_new_Dwg_BLOCKLOOKUPACTION_lut, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKLOOKUPACTION_lut", _wrap_delete_Dwg_BLOCKLOOKUPACTION_lut, METH_O, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_swigregister", Dwg_BLOCKLOOKUPACTION_lut_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKLOOKUPACTION_lut_swiginit", Dwg_BLOCKLOOKUPACTION_lut_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_parent_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_parent_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_name_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_name_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_be_major_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_be_major_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_be_minor_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_be_minor_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_eed1071_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_eed1071_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_display_location_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_display_location_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_num_actions_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_num_actions_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_actions_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_actions_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_num_deps_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_num_deps_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_deps_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_deps_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numelems_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numelems_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numelems_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numelems_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numrows_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numrows_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numrows_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numrows_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numcols_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numcols_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_numcols_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_numcols_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_lut_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_lut_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_lut_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_lut_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_exprs_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_exprs_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_exprs_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_exprs_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_b280_set", _wrap_Dwg_Object_BLOCKLOOKUPACTION_b280_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_b280_get", _wrap_Dwg_Object_BLOCKLOOKUPACTION_b280_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLOOKUPACTION", _wrap_new_Dwg_Object_BLOCKLOOKUPACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLOOKUPACTION", _wrap_delete_Dwg_Object_BLOCKLOOKUPACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_swigregister", Dwg_Object_BLOCKLOOKUPACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPACTION_swiginit", Dwg_Object_BLOCKLOOKUPACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_parent_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_parent_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_name_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_name_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_be_major_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_be_major_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKLOOKUPGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLOOKUPGRIP", _wrap_new_Dwg_Object_BLOCKLOOKUPGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLOOKUPGRIP", _wrap_delete_Dwg_Object_BLOCKLOOKUPGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_swigregister", Dwg_Object_BLOCKLOOKUPGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPGRIP_swiginit", Dwg_Object_BLOCKLOOKUPGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_name_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_name_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_num_propinfos_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_lookup_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_index_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_index_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_index_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_get", _wrap_Dwg_Object_BLOCKLOOKUPPARAMETER_unknown_t_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKLOOKUPPARAMETER", _wrap_new_Dwg_Object_BLOCKLOOKUPPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKLOOKUPPARAMETER", _wrap_delete_Dwg_Object_BLOCKLOOKUPPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_swigregister", Dwg_Object_BLOCKLOOKUPPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKLOOKUPPARAMETER_swiginit", Dwg_Object_BLOCKLOOKUPPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_parent_set", _wrap_Dwg_Object_BLOCKMOVEACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_parent_get", _wrap_Dwg_Object_BLOCKMOVEACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKMOVEACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKMOVEACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_name_set", _wrap_Dwg_Object_BLOCKMOVEACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_name_get", _wrap_Dwg_Object_BLOCKMOVEACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_be_major_set", _wrap_Dwg_Object_BLOCKMOVEACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_be_major_get", _wrap_Dwg_Object_BLOCKMOVEACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_be_minor_set", _wrap_Dwg_Object_BLOCKMOVEACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_be_minor_get", _wrap_Dwg_Object_BLOCKMOVEACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_eed1071_set", _wrap_Dwg_Object_BLOCKMOVEACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_eed1071_get", _wrap_Dwg_Object_BLOCKMOVEACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_display_location_set", _wrap_Dwg_Object_BLOCKMOVEACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_display_location_get", _wrap_Dwg_Object_BLOCKMOVEACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_num_actions_set", _wrap_Dwg_Object_BLOCKMOVEACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_num_actions_get", _wrap_Dwg_Object_BLOCKMOVEACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_actions_set", _wrap_Dwg_Object_BLOCKMOVEACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_actions_get", _wrap_Dwg_Object_BLOCKMOVEACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_num_deps_set", _wrap_Dwg_Object_BLOCKMOVEACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_num_deps_get", _wrap_Dwg_Object_BLOCKMOVEACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_deps_set", _wrap_Dwg_Object_BLOCKMOVEACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_deps_get", _wrap_Dwg_Object_BLOCKMOVEACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKMOVEACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKMOVEACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_action_offset_x_set", _wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_x_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_action_offset_x_get", _wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_x_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_action_offset_y_set", _wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_y_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_action_offset_y_get", _wrap_Dwg_Object_BLOCKMOVEACTION_action_offset_y_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_angle_offset_set", _wrap_Dwg_Object_BLOCKMOVEACTION_angle_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_angle_offset_get", _wrap_Dwg_Object_BLOCKMOVEACTION_angle_offset_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKMOVEACTION", _wrap_new_Dwg_Object_BLOCKMOVEACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKMOVEACTION", _wrap_delete_Dwg_Object_BLOCKMOVEACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_swigregister", Dwg_Object_BLOCKMOVEACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKMOVEACTION_swiginit", Dwg_Object_BLOCKMOVEACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_name_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_name_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_def_pt_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_num_propinfos_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_position_name_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_position_name_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_position_desc_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_position_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_get", _wrap_Dwg_Object_BLOCKPOINTPARAMETER_def_label_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPOINTPARAMETER", _wrap_new_Dwg_Object_BLOCKPOINTPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPOINTPARAMETER", _wrap_delete_Dwg_Object_BLOCKPOINTPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_swigregister", Dwg_Object_BLOCKPOINTPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOINTPARAMETER_swiginit", Dwg_Object_BLOCKPOINTPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_parent_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_parent_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_name_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_name_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_be_major_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_be_major_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKPOLARGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPOLARGRIP", _wrap_new_Dwg_Object_BLOCKPOLARGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPOLARGRIP", _wrap_delete_Dwg_Object_BLOCKPOLARGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_swigregister", Dwg_Object_BLOCKPOLARGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARGRIP_swiginit", Dwg_Object_BLOCKPOLARGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_name_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_name_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_name_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_name_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_offset_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_offset_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_offset_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_angle_value_set_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_get", _wrap_Dwg_Object_BLOCKPOLARPARAMETER_distance_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPOLARPARAMETER", _wrap_new_Dwg_Object_BLOCKPOLARPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPOLARPARAMETER", _wrap_delete_Dwg_Object_BLOCKPOLARPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_swigregister", Dwg_Object_BLOCKPOLARPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARPARAMETER_swiginit", Dwg_Object_BLOCKPOLARPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_name_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_hdls_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_hdls_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_shorts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_num_codes_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_get", _wrap_Dwg_Object_BLOCKPOLARSTRETCHACTION_codes_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPOLARSTRETCHACTION", _wrap_new_Dwg_Object_BLOCKPOLARSTRETCHACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPOLARSTRETCHACTION", _wrap_delete_Dwg_Object_BLOCKPOLARSTRETCHACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_swigregister", Dwg_Object_BLOCKPOLARSTRETCHACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPOLARSTRETCHACTION_swiginit", Dwg_Object_BLOCKPOLARSTRETCHACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLE_parent_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLE_parent_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLE_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPROPERTIESTABLE", _wrap_new_Dwg_Object_BLOCKPROPERTIESTABLE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPROPERTIESTABLE", _wrap_delete_Dwg_Object_BLOCKPROPERTIESTABLE, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLE_swigregister", Dwg_Object_BLOCKPROPERTIESTABLE_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLE_swiginit", Dwg_Object_BLOCKPROPERTIESTABLE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKPROPERTIESTABLEGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKPROPERTIESTABLEGRIP", _wrap_new_Dwg_Object_BLOCKPROPERTIESTABLEGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKPROPERTIESTABLEGRIP", _wrap_delete_Dwg_Object_BLOCKPROPERTIESTABLEGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swigregister", Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swiginit", Dwg_Object_BLOCKPROPERTIESTABLEGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_parent_set", _wrap_Dwg_Object_BLOCKREPRESENTATION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_parent_get", _wrap_Dwg_Object_BLOCKREPRESENTATION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_flag_set", _wrap_Dwg_Object_BLOCKREPRESENTATION_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_flag_get", _wrap_Dwg_Object_BLOCKREPRESENTATION_flag_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_block_set", _wrap_Dwg_Object_BLOCKREPRESENTATION_block_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_block_get", _wrap_Dwg_Object_BLOCKREPRESENTATION_block_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKREPRESENTATION", _wrap_new_Dwg_Object_BLOCKREPRESENTATION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKREPRESENTATION", _wrap_delete_Dwg_Object_BLOCKREPRESENTATION, METH_O, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_swigregister", Dwg_Object_BLOCKREPRESENTATION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKREPRESENTATION_swiginit", Dwg_Object_BLOCKREPRESENTATION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_parent_set", _wrap_Dwg_Object_BLOCKROTATEACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_parent_get", _wrap_Dwg_Object_BLOCKROTATEACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKROTATEACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKROTATEACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_name_set", _wrap_Dwg_Object_BLOCKROTATEACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_name_get", _wrap_Dwg_Object_BLOCKROTATEACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_be_major_set", _wrap_Dwg_Object_BLOCKROTATEACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_be_major_get", _wrap_Dwg_Object_BLOCKROTATEACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_be_minor_set", _wrap_Dwg_Object_BLOCKROTATEACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_be_minor_get", _wrap_Dwg_Object_BLOCKROTATEACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_eed1071_set", _wrap_Dwg_Object_BLOCKROTATEACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_eed1071_get", _wrap_Dwg_Object_BLOCKROTATEACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_display_location_set", _wrap_Dwg_Object_BLOCKROTATEACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_display_location_get", _wrap_Dwg_Object_BLOCKROTATEACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_num_actions_set", _wrap_Dwg_Object_BLOCKROTATEACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_num_actions_get", _wrap_Dwg_Object_BLOCKROTATEACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_actions_set", _wrap_Dwg_Object_BLOCKROTATEACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_actions_get", _wrap_Dwg_Object_BLOCKROTATEACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_num_deps_set", _wrap_Dwg_Object_BLOCKROTATEACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_num_deps_get", _wrap_Dwg_Object_BLOCKROTATEACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_deps_set", _wrap_Dwg_Object_BLOCKROTATEACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_deps_get", _wrap_Dwg_Object_BLOCKROTATEACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_offset_set", _wrap_Dwg_Object_BLOCKROTATEACTION_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_offset_get", _wrap_Dwg_Object_BLOCKROTATEACTION_offset_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKROTATEACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKROTATEACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_dependent_set", _wrap_Dwg_Object_BLOCKROTATEACTION_dependent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_dependent_get", _wrap_Dwg_Object_BLOCKROTATEACTION_dependent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_base_pt_set", _wrap_Dwg_Object_BLOCKROTATEACTION_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_base_pt_get", _wrap_Dwg_Object_BLOCKROTATEACTION_base_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKROTATEACTION", _wrap_new_Dwg_Object_BLOCKROTATEACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKROTATEACTION", _wrap_delete_Dwg_Object_BLOCKROTATEACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_swigregister", Dwg_Object_BLOCKROTATEACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATEACTION_swiginit", Dwg_Object_BLOCKROTATEACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_parent_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_parent_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_name_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_name_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_be_major_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_be_major_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKROTATIONGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKROTATIONGRIP", _wrap_new_Dwg_Object_BLOCKROTATIONGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKROTATIONGRIP", _wrap_delete_Dwg_Object_BLOCKROTATIONGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_swigregister", Dwg_Object_BLOCKROTATIONGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONGRIP_swiginit", Dwg_Object_BLOCKROTATIONGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_name_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_name_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_def_base_angle_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_get", _wrap_Dwg_Object_BLOCKROTATIONPARAMETER_angle_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKROTATIONPARAMETER", _wrap_new_Dwg_Object_BLOCKROTATIONPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKROTATIONPARAMETER", _wrap_delete_Dwg_Object_BLOCKROTATIONPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_swigregister", Dwg_Object_BLOCKROTATIONPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKROTATIONPARAMETER_swiginit", Dwg_Object_BLOCKROTATIONPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_parent_set", _wrap_Dwg_Object_BLOCKSCALEACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_parent_get", _wrap_Dwg_Object_BLOCKSCALEACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKSCALEACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKSCALEACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_name_set", _wrap_Dwg_Object_BLOCKSCALEACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_name_get", _wrap_Dwg_Object_BLOCKSCALEACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_be_major_set", _wrap_Dwg_Object_BLOCKSCALEACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_be_major_get", _wrap_Dwg_Object_BLOCKSCALEACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_be_minor_set", _wrap_Dwg_Object_BLOCKSCALEACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_be_minor_get", _wrap_Dwg_Object_BLOCKSCALEACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_eed1071_set", _wrap_Dwg_Object_BLOCKSCALEACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_eed1071_get", _wrap_Dwg_Object_BLOCKSCALEACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_display_location_set", _wrap_Dwg_Object_BLOCKSCALEACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_display_location_get", _wrap_Dwg_Object_BLOCKSCALEACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_num_actions_set", _wrap_Dwg_Object_BLOCKSCALEACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_num_actions_get", _wrap_Dwg_Object_BLOCKSCALEACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_actions_set", _wrap_Dwg_Object_BLOCKSCALEACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_actions_get", _wrap_Dwg_Object_BLOCKSCALEACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_num_deps_set", _wrap_Dwg_Object_BLOCKSCALEACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_num_deps_get", _wrap_Dwg_Object_BLOCKSCALEACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_deps_set", _wrap_Dwg_Object_BLOCKSCALEACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_deps_get", _wrap_Dwg_Object_BLOCKSCALEACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_offset_set", _wrap_Dwg_Object_BLOCKSCALEACTION_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_offset_get", _wrap_Dwg_Object_BLOCKSCALEACTION_offset_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKSCALEACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKSCALEACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_dependent_set", _wrap_Dwg_Object_BLOCKSCALEACTION_dependent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_dependent_get", _wrap_Dwg_Object_BLOCKSCALEACTION_dependent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_base_pt_set", _wrap_Dwg_Object_BLOCKSCALEACTION_base_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_base_pt_get", _wrap_Dwg_Object_BLOCKSCALEACTION_base_pt_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKSCALEACTION", _wrap_new_Dwg_Object_BLOCKSCALEACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKSCALEACTION", _wrap_delete_Dwg_Object_BLOCKSCALEACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_swigregister", Dwg_Object_BLOCKSCALEACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKSCALEACTION_swiginit", Dwg_Object_BLOCKSCALEACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_parent_set", _wrap_Dwg_BLOCKSTRETCHACTION_handles_parent_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_parent_get", _wrap_Dwg_BLOCKSTRETCHACTION_handles_parent_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_hdl_set", _wrap_Dwg_BLOCKSTRETCHACTION_handles_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_hdl_get", _wrap_Dwg_BLOCKSTRETCHACTION_handles_hdl_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set", _wrap_Dwg_BLOCKSTRETCHACTION_handles_num_indexes_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_num_indexes_get", _wrap_Dwg_BLOCKSTRETCHACTION_handles_num_indexes_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_indexes_set", _wrap_Dwg_BLOCKSTRETCHACTION_handles_indexes_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_indexes_get", _wrap_Dwg_BLOCKSTRETCHACTION_handles_indexes_get, METH_O, NULL},
	 { "new_Dwg_BLOCKSTRETCHACTION_handles", _wrap_new_Dwg_BLOCKSTRETCHACTION_handles, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKSTRETCHACTION_handles", _wrap_delete_Dwg_BLOCKSTRETCHACTION_handles, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_swigregister", Dwg_BLOCKSTRETCHACTION_handles_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_handles_swiginit", Dwg_BLOCKSTRETCHACTION_handles_swiginit, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_parent_set", _wrap_Dwg_BLOCKSTRETCHACTION_codes_parent_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_parent_get", _wrap_Dwg_BLOCKSTRETCHACTION_codes_parent_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_bl95_set", _wrap_Dwg_BLOCKSTRETCHACTION_codes_bl95_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_bl95_get", _wrap_Dwg_BLOCKSTRETCHACTION_codes_bl95_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set", _wrap_Dwg_BLOCKSTRETCHACTION_codes_num_indexes_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_num_indexes_get", _wrap_Dwg_BLOCKSTRETCHACTION_codes_num_indexes_get, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_indexes_set", _wrap_Dwg_BLOCKSTRETCHACTION_codes_indexes_set, METH_VARARGS, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_indexes_get", _wrap_Dwg_BLOCKSTRETCHACTION_codes_indexes_get, METH_O, NULL},
	 { "new_Dwg_BLOCKSTRETCHACTION_codes", _wrap_new_Dwg_BLOCKSTRETCHACTION_codes, METH_NOARGS, NULL},
	 { "delete_Dwg_BLOCKSTRETCHACTION_codes", _wrap_delete_Dwg_BLOCKSTRETCHACTION_codes, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_swigregister", Dwg_BLOCKSTRETCHACTION_codes_swigregister, METH_O, NULL},
	 { "Dwg_BLOCKSTRETCHACTION_codes_swiginit", Dwg_BLOCKSTRETCHACTION_codes_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_parent_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_parent_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_evalexpr_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_name_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_name_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_be_major_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_be_major_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_be_minor_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_be_minor_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_eed1071_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_eed1071_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_display_location_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_display_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_display_location_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_display_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_actions_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_actions_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_actions_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_actions_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_deps_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_deps_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_deps_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_deps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_deps_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_deps_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_conn_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_conn_pts_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_conn_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_pts_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_pts_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_pts_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_pts_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_pts_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_pts_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_hdls_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_hdls_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_hdls_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_hdls_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_hdls_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_hdls_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_codes_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_codes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_num_codes_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_num_codes_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_codes_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_codes_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_codes_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_codes_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_x_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_action_offset_y_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set", _wrap_Dwg_Object_BLOCKSTRETCHACTION_angle_offset_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_angle_offset_get", _wrap_Dwg_Object_BLOCKSTRETCHACTION_angle_offset_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKSTRETCHACTION", _wrap_new_Dwg_Object_BLOCKSTRETCHACTION, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKSTRETCHACTION", _wrap_delete_Dwg_Object_BLOCKSTRETCHACTION, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_swigregister", Dwg_Object_BLOCKSTRETCHACTION_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKSTRETCHACTION_swiginit", Dwg_Object_BLOCKSTRETCHACTION_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_name_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_name_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_def_pt_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_def_pt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_def_pt_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_def_pt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_num_propinfos_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_flag_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_flag_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_flag_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_flag_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_assocvariable_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_assocvariable_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_assocvariable_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_expr_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_expr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_expr_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_expr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_value_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_value_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_type_set", _wrap_Dwg_Object_BLOCKUSERPARAMETER_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_type_get", _wrap_Dwg_Object_BLOCKUSERPARAMETER_type_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKUSERPARAMETER", _wrap_new_Dwg_Object_BLOCKUSERPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKUSERPARAMETER", _wrap_delete_Dwg_Object_BLOCKUSERPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_swigregister", Dwg_Object_BLOCKUSERPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKUSERPARAMETER_swiginit", Dwg_Object_BLOCKUSERPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_parent_set", _wrap_Dwg_Object_BLOCKXYGRIP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_parent_get", _wrap_Dwg_Object_BLOCKXYGRIP_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_evalexpr_set", _wrap_Dwg_Object_BLOCKXYGRIP_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_evalexpr_get", _wrap_Dwg_Object_BLOCKXYGRIP_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_name_set", _wrap_Dwg_Object_BLOCKXYGRIP_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_name_get", _wrap_Dwg_Object_BLOCKXYGRIP_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_be_major_set", _wrap_Dwg_Object_BLOCKXYGRIP_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_be_major_get", _wrap_Dwg_Object_BLOCKXYGRIP_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_be_minor_set", _wrap_Dwg_Object_BLOCKXYGRIP_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_be_minor_get", _wrap_Dwg_Object_BLOCKXYGRIP_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_eed1071_set", _wrap_Dwg_Object_BLOCKXYGRIP_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_eed1071_get", _wrap_Dwg_Object_BLOCKXYGRIP_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_bl91_set", _wrap_Dwg_Object_BLOCKXYGRIP_bg_bl91_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_bl91_get", _wrap_Dwg_Object_BLOCKXYGRIP_bg_bl91_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_bl92_set", _wrap_Dwg_Object_BLOCKXYGRIP_bg_bl92_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_bl92_get", _wrap_Dwg_Object_BLOCKXYGRIP_bg_bl92_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_location_set", _wrap_Dwg_Object_BLOCKXYGRIP_bg_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_location_get", _wrap_Dwg_Object_BLOCKXYGRIP_bg_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set", _wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_get", _wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set", _wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_get", _wrap_Dwg_Object_BLOCKXYGRIP_bg_insert_cycling_weight_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKXYGRIP", _wrap_new_Dwg_Object_BLOCKXYGRIP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKXYGRIP", _wrap_delete_Dwg_Object_BLOCKXYGRIP, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_swigregister", Dwg_Object_BLOCKXYGRIP_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYGRIP_swiginit", Dwg_Object_BLOCKXYGRIP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_parent_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_parent_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_parent_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_evalexpr_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_evalexpr_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_evalexpr_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_name_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_name_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_name_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_be_major_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_be_major_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_be_major_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_be_major_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_be_minor_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_be_minor_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_be_minor_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_be_minor_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_eed1071_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_eed1071_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_eed1071_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_eed1071_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_show_properties_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_show_properties_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_show_properties_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_show_properties_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_chain_actions_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_chain_actions_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_chain_actions_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_chain_actions_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_def_basept_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_def_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_def_basept_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_def_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_def_endpt_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_def_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_def_endpt_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_def_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop1_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop1_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop1_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop1_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop2_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop2_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop2_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop2_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop3_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop3_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop3_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop3_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop4_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop4_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop4_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop4_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop_states_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop_states_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_prop_states_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_prop_states_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_parameter_base_location_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_upd_basept_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_upd_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_upd_basept_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_upd_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_basept_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_basept_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_basept_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_basept_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_upd_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_upd_endpt_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_upd_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_endpt_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_endpt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_endpt_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_endpt_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_label_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_label_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_label_desc_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_label_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_label_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_label_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_label_desc_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_label_desc_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_value_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_value_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_value_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_value_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_value_set_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_x_value_set_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_x_value_set_get, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_value_set_set", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_y_value_set_get", _wrap_Dwg_Object_BLOCKXYPARAMETER_y_value_set_get, METH_O, NULL},
	 { "new_Dwg_Object_BLOCKXYPARAMETER", _wrap_new_Dwg_Object_BLOCKXYPARAMETER, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_BLOCKXYPARAMETER", _wrap_delete_Dwg_Object_BLOCKXYPARAMETER, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_swigregister", Dwg_Object_BLOCKXYPARAMETER_swigregister, METH_O, NULL},
	 { "Dwg_Object_BLOCKXYPARAMETER_swiginit", Dwg_Object_BLOCKXYPARAMETER_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set", _wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_get", _wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_parent_get, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set", _wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_set, METH_VARARGS, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_get", _wrap_Dwg_Object_DYNAMICBLOCKPROXYNODE_evalexpr_get, METH_O, NULL},
	 { "new_Dwg_Object_DYNAMICBLOCKPROXYNODE", _wrap_new_Dwg_Object_DYNAMICBLOCKPROXYNODE, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_DYNAMICBLOCKPROXYNODE", _wrap_delete_Dwg_Object_DYNAMICBLOCKPROXYNODE, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_swigregister", Dwg_Object_DYNAMICBLOCKPROXYNODE_swigregister, METH_O, NULL},
	 { "Dwg_Object_DYNAMICBLOCKPROXYNODE_swiginit", Dwg_Object_DYNAMICBLOCKPROXYNODE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_parent_set", _wrap_Dwg_POINTCLOUD_IntensityStyle_parent_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_parent_get", _wrap_Dwg_POINTCLOUD_IntensityStyle_parent_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_min_intensity_set", _wrap_Dwg_POINTCLOUD_IntensityStyle_min_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_min_intensity_get", _wrap_Dwg_POINTCLOUD_IntensityStyle_min_intensity_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_max_intensity_set", _wrap_Dwg_POINTCLOUD_IntensityStyle_max_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_max_intensity_get", _wrap_Dwg_POINTCLOUD_IntensityStyle_max_intensity_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set", _wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_get", _wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_low_treshold_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set", _wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_get", _wrap_Dwg_POINTCLOUD_IntensityStyle_intensity_high_treshold_get, METH_O, NULL},
	 { "new_Dwg_POINTCLOUD_IntensityStyle", _wrap_new_Dwg_POINTCLOUD_IntensityStyle, METH_NOARGS, NULL},
	 { "delete_Dwg_POINTCLOUD_IntensityStyle", _wrap_delete_Dwg_POINTCLOUD_IntensityStyle, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_swigregister", Dwg_POINTCLOUD_IntensityStyle_swigregister, METH_O, NULL},
	 { "Dwg_POINTCLOUD_IntensityStyle_swiginit", Dwg_POINTCLOUD_IntensityStyle_swiginit, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_parent_set", _wrap_Dwg_POINTCLOUD_Clippings_parent_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_parent_get", _wrap_Dwg_POINTCLOUD_Clippings_parent_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_is_inverted_set", _wrap_Dwg_POINTCLOUD_Clippings_is_inverted_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_is_inverted_get", _wrap_Dwg_POINTCLOUD_Clippings_is_inverted_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_type_set", _wrap_Dwg_POINTCLOUD_Clippings_type_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_type_get", _wrap_Dwg_POINTCLOUD_Clippings_type_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_num_vertices_set", _wrap_Dwg_POINTCLOUD_Clippings_num_vertices_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_num_vertices_get", _wrap_Dwg_POINTCLOUD_Clippings_num_vertices_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_vertices_set", _wrap_Dwg_POINTCLOUD_Clippings_vertices_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_vertices_get", _wrap_Dwg_POINTCLOUD_Clippings_vertices_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_z_min_set", _wrap_Dwg_POINTCLOUD_Clippings_z_min_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_z_min_get", _wrap_Dwg_POINTCLOUD_Clippings_z_min_get, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_z_max_set", _wrap_Dwg_POINTCLOUD_Clippings_z_max_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUD_Clippings_z_max_get", _wrap_Dwg_POINTCLOUD_Clippings_z_max_get, METH_O, NULL},
	 { "new_Dwg_POINTCLOUD_Clippings", _wrap_new_Dwg_POINTCLOUD_Clippings, METH_NOARGS, NULL},
	 { "delete_Dwg_POINTCLOUD_Clippings", _wrap_delete_Dwg_POINTCLOUD_Clippings, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_swigregister", Dwg_POINTCLOUD_Clippings_swigregister, METH_O, NULL},
	 { "Dwg_POINTCLOUD_Clippings_swiginit", Dwg_POINTCLOUD_Clippings_swiginit, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_parent_set", _wrap_Dwg_POINTCLOUDEX_Croppings_parent_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_parent_get", _wrap_Dwg_POINTCLOUDEX_Croppings_parent_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_type_set", _wrap_Dwg_POINTCLOUDEX_Croppings_type_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_type_get", _wrap_Dwg_POINTCLOUDEX_Croppings_type_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_is_inside_set", _wrap_Dwg_POINTCLOUDEX_Croppings_is_inside_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_is_inside_get", _wrap_Dwg_POINTCLOUDEX_Croppings_is_inside_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_is_inverted_set", _wrap_Dwg_POINTCLOUDEX_Croppings_is_inverted_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_is_inverted_get", _wrap_Dwg_POINTCLOUDEX_Croppings_is_inverted_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_plane_set", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_plane_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_plane_get", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_plane_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_x_dir_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_x_dir_get", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_x_dir_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_y_dir_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_crop_y_dir_get", _wrap_Dwg_POINTCLOUDEX_Croppings_crop_y_dir_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_num_pts_set", _wrap_Dwg_POINTCLOUDEX_Croppings_num_pts_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_num_pts_get", _wrap_Dwg_POINTCLOUDEX_Croppings_num_pts_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_pts_set", _wrap_Dwg_POINTCLOUDEX_Croppings_pts_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_pts_get", _wrap_Dwg_POINTCLOUDEX_Croppings_pts_get, METH_O, NULL},
	 { "new_Dwg_POINTCLOUDEX_Croppings", _wrap_new_Dwg_POINTCLOUDEX_Croppings, METH_NOARGS, NULL},
	 { "delete_Dwg_POINTCLOUDEX_Croppings", _wrap_delete_Dwg_POINTCLOUDEX_Croppings, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_swigregister", Dwg_POINTCLOUDEX_Croppings_swigregister, METH_O, NULL},
	 { "Dwg_POINTCLOUDEX_Croppings_swiginit", Dwg_POINTCLOUDEX_Croppings_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_parent_set", _wrap_Dwg_Entity_POINTCLOUD_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_parent_get", _wrap_Dwg_Entity_POINTCLOUD_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_class_version_set", _wrap_Dwg_Entity_POINTCLOUD_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_class_version_get", _wrap_Dwg_Entity_POINTCLOUD_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_origin_set", _wrap_Dwg_Entity_POINTCLOUD_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_origin_get", _wrap_Dwg_Entity_POINTCLOUD_origin_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_saved_filename_set", _wrap_Dwg_Entity_POINTCLOUD_saved_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_saved_filename_get", _wrap_Dwg_Entity_POINTCLOUD_saved_filename_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_num_source_files_set", _wrap_Dwg_Entity_POINTCLOUD_num_source_files_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_num_source_files_get", _wrap_Dwg_Entity_POINTCLOUD_num_source_files_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_source_files_set", _wrap_Dwg_Entity_POINTCLOUD_source_files_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_source_files_get", _wrap_Dwg_Entity_POINTCLOUD_source_files_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_extents_min_set", _wrap_Dwg_Entity_POINTCLOUD_extents_min_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_extents_min_get", _wrap_Dwg_Entity_POINTCLOUD_extents_min_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_extents_max_set", _wrap_Dwg_Entity_POINTCLOUD_extents_max_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_extents_max_get", _wrap_Dwg_Entity_POINTCLOUD_extents_max_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_numpoints_set", _wrap_Dwg_Entity_POINTCLOUD_numpoints_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_numpoints_get", _wrap_Dwg_Entity_POINTCLOUD_numpoints_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_name_set", _wrap_Dwg_Entity_POINTCLOUD_ucs_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_name_get", _wrap_Dwg_Entity_POINTCLOUD_ucs_name_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_origin_set", _wrap_Dwg_Entity_POINTCLOUD_ucs_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_origin_get", _wrap_Dwg_Entity_POINTCLOUD_ucs_origin_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_x_dir_set", _wrap_Dwg_Entity_POINTCLOUD_ucs_x_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_x_dir_get", _wrap_Dwg_Entity_POINTCLOUD_ucs_x_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_y_dir_set", _wrap_Dwg_Entity_POINTCLOUD_ucs_y_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_y_dir_get", _wrap_Dwg_Entity_POINTCLOUD_ucs_y_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_z_dir_set", _wrap_Dwg_Entity_POINTCLOUD_ucs_z_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_ucs_z_dir_get", _wrap_Dwg_Entity_POINTCLOUD_ucs_z_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_pointclouddef_set", _wrap_Dwg_Entity_POINTCLOUD_pointclouddef_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_pointclouddef_get", _wrap_Dwg_Entity_POINTCLOUD_pointclouddef_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_reactor_set", _wrap_Dwg_Entity_POINTCLOUD_reactor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_reactor_get", _wrap_Dwg_Entity_POINTCLOUD_reactor_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_show_intensity_set", _wrap_Dwg_Entity_POINTCLOUD_show_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_show_intensity_get", _wrap_Dwg_Entity_POINTCLOUD_show_intensity_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_intensity_scheme_set", _wrap_Dwg_Entity_POINTCLOUD_intensity_scheme_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_intensity_scheme_get", _wrap_Dwg_Entity_POINTCLOUD_intensity_scheme_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_intensity_style_set", _wrap_Dwg_Entity_POINTCLOUD_intensity_style_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_intensity_style_get", _wrap_Dwg_Entity_POINTCLOUD_intensity_style_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_show_clipping_set", _wrap_Dwg_Entity_POINTCLOUD_show_clipping_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_show_clipping_get", _wrap_Dwg_Entity_POINTCLOUD_show_clipping_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_num_clippings_set", _wrap_Dwg_Entity_POINTCLOUD_num_clippings_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_num_clippings_get", _wrap_Dwg_Entity_POINTCLOUD_num_clippings_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_clippings_set", _wrap_Dwg_Entity_POINTCLOUD_clippings_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUD_clippings_get", _wrap_Dwg_Entity_POINTCLOUD_clippings_get, METH_O, NULL},
	 { "new_Dwg_Entity_POINTCLOUD", _wrap_new_Dwg_Entity_POINTCLOUD, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POINTCLOUD", _wrap_delete_Dwg_Entity_POINTCLOUD, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_swigregister", Dwg_Entity_POINTCLOUD_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUD_swiginit", Dwg_Entity_POINTCLOUD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_parent_set", _wrap_Dwg_Entity_POINTCLOUDEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_parent_get", _wrap_Dwg_Entity_POINTCLOUDEX_parent_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_class_version_set", _wrap_Dwg_Entity_POINTCLOUDEX_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_class_version_get", _wrap_Dwg_Entity_POINTCLOUDEX_class_version_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_extents_min_set", _wrap_Dwg_Entity_POINTCLOUDEX_extents_min_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_extents_min_get", _wrap_Dwg_Entity_POINTCLOUDEX_extents_min_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_extents_max_set", _wrap_Dwg_Entity_POINTCLOUDEX_extents_max_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_extents_max_get", _wrap_Dwg_Entity_POINTCLOUDEX_extents_max_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_origin_set", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_origin_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_origin_get", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_origin_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_x_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_x_dir_get", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_x_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_y_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_y_dir_get", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_y_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_z_dir_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_ucs_z_dir_get", _wrap_Dwg_Entity_POINTCLOUDEX_ucs_z_dir_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_is_locked_set", _wrap_Dwg_Entity_POINTCLOUDEX_is_locked_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_is_locked_get", _wrap_Dwg_Entity_POINTCLOUDEX_is_locked_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_pointclouddefex_set", _wrap_Dwg_Entity_POINTCLOUDEX_pointclouddefex_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_pointclouddefex_get", _wrap_Dwg_Entity_POINTCLOUDEX_pointclouddefex_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_reactor_set", _wrap_Dwg_Entity_POINTCLOUDEX_reactor_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_reactor_get", _wrap_Dwg_Entity_POINTCLOUDEX_reactor_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_name_set", _wrap_Dwg_Entity_POINTCLOUDEX_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_name_get", _wrap_Dwg_Entity_POINTCLOUDEX_name_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_show_intensity_set", _wrap_Dwg_Entity_POINTCLOUDEX_show_intensity_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_show_intensity_get", _wrap_Dwg_Entity_POINTCLOUDEX_show_intensity_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_stylization_type_set", _wrap_Dwg_Entity_POINTCLOUDEX_stylization_type_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_stylization_type_get", _wrap_Dwg_Entity_POINTCLOUDEX_stylization_type_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_get", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_colorscheme_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set", _wrap_Dwg_Entity_POINTCLOUDEX_cur_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_cur_colorscheme_get", _wrap_Dwg_Entity_POINTCLOUDEX_cur_colorscheme_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set", _wrap_Dwg_Entity_POINTCLOUDEX_classification_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_classification_colorscheme_get", _wrap_Dwg_Entity_POINTCLOUDEX_classification_colorscheme_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_min_set", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_min_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_min_get", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_min_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_max_set", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_max_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_max_get", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_max_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_min_set", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_min_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_min_get", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_min_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_max_set", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_max_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_max_get", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_max_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_get", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_out_of_range_behavior_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_get", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_out_of_range_behavior_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_get", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_apply_to_fixed_range_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_get", _wrap_Dwg_Entity_POINTCLOUDEX_intensity_as_gradient_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_get", _wrap_Dwg_Entity_POINTCLOUDEX_elevation_as_gradient_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_show_cropping_set", _wrap_Dwg_Entity_POINTCLOUDEX_show_cropping_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_show_cropping_get", _wrap_Dwg_Entity_POINTCLOUDEX_show_cropping_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_unknown_bl0_set", _wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl0_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_unknown_bl0_get", _wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl0_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_unknown_bl1_set", _wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl1_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_unknown_bl1_get", _wrap_Dwg_Entity_POINTCLOUDEX_unknown_bl1_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_num_croppings_set", _wrap_Dwg_Entity_POINTCLOUDEX_num_croppings_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_num_croppings_get", _wrap_Dwg_Entity_POINTCLOUDEX_num_croppings_get, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_croppings_set", _wrap_Dwg_Entity_POINTCLOUDEX_croppings_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_croppings_get", _wrap_Dwg_Entity_POINTCLOUDEX_croppings_get, METH_O, NULL},
	 { "new_Dwg_Entity_POINTCLOUDEX", _wrap_new_Dwg_Entity_POINTCLOUDEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_POINTCLOUDEX", _wrap_delete_Dwg_Entity_POINTCLOUDEX, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_swigregister", Dwg_Entity_POINTCLOUDEX_swigregister, METH_O, NULL},
	 { "Dwg_Entity_POINTCLOUDEX_swiginit", Dwg_Entity_POINTCLOUDEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_parent_set", _wrap_Dwg_Object_POINTCLOUDDEF_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_parent_get", _wrap_Dwg_Object_POINTCLOUDDEF_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_class_version_set", _wrap_Dwg_Object_POINTCLOUDDEF_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_class_version_get", _wrap_Dwg_Object_POINTCLOUDDEF_class_version_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_source_filename_set", _wrap_Dwg_Object_POINTCLOUDDEF_source_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_source_filename_get", _wrap_Dwg_Object_POINTCLOUDDEF_source_filename_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_is_loaded_set", _wrap_Dwg_Object_POINTCLOUDDEF_is_loaded_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_is_loaded_get", _wrap_Dwg_Object_POINTCLOUDDEF_is_loaded_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_numpoints_set", _wrap_Dwg_Object_POINTCLOUDDEF_numpoints_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_numpoints_get", _wrap_Dwg_Object_POINTCLOUDDEF_numpoints_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_extents_min_set", _wrap_Dwg_Object_POINTCLOUDDEF_extents_min_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_extents_min_get", _wrap_Dwg_Object_POINTCLOUDDEF_extents_min_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_extents_max_set", _wrap_Dwg_Object_POINTCLOUDDEF_extents_max_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_extents_max_get", _wrap_Dwg_Object_POINTCLOUDDEF_extents_max_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTCLOUDDEF", _wrap_new_Dwg_Object_POINTCLOUDDEF, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTCLOUDDEF", _wrap_delete_Dwg_Object_POINTCLOUDDEF, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_swigregister", Dwg_Object_POINTCLOUDDEF_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_swiginit", Dwg_Object_POINTCLOUDDEF_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_parent_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_parent_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_class_version_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_class_version_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_class_version_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_source_filename_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_source_filename_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_source_filename_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_source_filename_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_is_loaded_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_is_loaded_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_is_loaded_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_is_loaded_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_numpoints_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_numpoints_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_numpoints_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_numpoints_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_extents_min_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_extents_min_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_extents_min_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_extents_min_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_extents_max_set", _wrap_Dwg_Object_POINTCLOUDDEFEX_extents_max_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_extents_max_get", _wrap_Dwg_Object_POINTCLOUDDEFEX_extents_max_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTCLOUDDEFEX", _wrap_new_Dwg_Object_POINTCLOUDDEFEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTCLOUDDEFEX", _wrap_delete_Dwg_Object_POINTCLOUDDEFEX, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_swigregister", Dwg_Object_POINTCLOUDDEFEX_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEFEX_swiginit", Dwg_Object_POINTCLOUDDEFEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_parent_get", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_get", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTCLOUDDEF_REACTOR", _wrap_new_Dwg_Object_POINTCLOUDDEF_REACTOR, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTCLOUDDEF_REACTOR", _wrap_delete_Dwg_Object_POINTCLOUDDEF_REACTOR, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_swigregister", Dwg_Object_POINTCLOUDDEF_REACTOR_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_swiginit", Dwg_Object_POINTCLOUDDEF_REACTOR_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_get", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_get", _wrap_Dwg_Object_POINTCLOUDDEF_REACTOR_EX_class_version_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTCLOUDDEF_REACTOR_EX", _wrap_new_Dwg_Object_POINTCLOUDDEF_REACTOR_EX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTCLOUDDEF_REACTOR_EX", _wrap_delete_Dwg_Object_POINTCLOUDDEF_REACTOR_EX, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swigregister", Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swiginit", Dwg_Object_POINTCLOUDDEF_REACTOR_EX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ColorRamp_parent_set", _wrap_Dwg_ColorRamp_parent_set, METH_VARARGS, NULL},
	 { "Dwg_ColorRamp_parent_get", _wrap_Dwg_ColorRamp_parent_get, METH_O, NULL},
	 { "Dwg_ColorRamp_colorscheme_set", _wrap_Dwg_ColorRamp_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_ColorRamp_colorscheme_get", _wrap_Dwg_ColorRamp_colorscheme_get, METH_O, NULL},
	 { "Dwg_ColorRamp_unknown_bl_set", _wrap_Dwg_ColorRamp_unknown_bl_set, METH_VARARGS, NULL},
	 { "Dwg_ColorRamp_unknown_bl_get", _wrap_Dwg_ColorRamp_unknown_bl_get, METH_O, NULL},
	 { "Dwg_ColorRamp_unknown_b_set", _wrap_Dwg_ColorRamp_unknown_b_set, METH_VARARGS, NULL},
	 { "Dwg_ColorRamp_unknown_b_get", _wrap_Dwg_ColorRamp_unknown_b_get, METH_O, NULL},
	 { "new_Dwg_ColorRamp", _wrap_new_Dwg_ColorRamp, METH_NOARGS, NULL},
	 { "delete_Dwg_ColorRamp", _wrap_delete_Dwg_ColorRamp, METH_O, NULL},
	 { "Dwg_ColorRamp_swigregister", Dwg_ColorRamp_swigregister, METH_O, NULL},
	 { "Dwg_ColorRamp_swiginit", Dwg_ColorRamp_swiginit, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_parent_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_parent_get", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_parent_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_get", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_class_version_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_get", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_num_ramps_get, METH_O, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_set, METH_VARARGS, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_get", _wrap_Dwg_POINTCLOUDCOLORMAP_Ramp_ramps_get, METH_O, NULL},
	 { "new_Dwg_POINTCLOUDCOLORMAP_Ramp", _wrap_new_Dwg_POINTCLOUDCOLORMAP_Ramp, METH_NOARGS, NULL},
	 { "delete_Dwg_POINTCLOUDCOLORMAP_Ramp", _wrap_delete_Dwg_POINTCLOUDCOLORMAP_Ramp, METH_O, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_swigregister", Dwg_POINTCLOUDCOLORMAP_Ramp_swigregister, METH_O, NULL},
	 { "Dwg_POINTCLOUDCOLORMAP_Ramp_swiginit", Dwg_POINTCLOUDCOLORMAP_Ramp_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_parent_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_parent_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_parent_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_class_version_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_class_version_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_class_version_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_intensity_colorscheme_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_elevation_colorscheme_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_def_classification_colorscheme_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_colorramps_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_colorramps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_colorramps_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_colorramps_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_num_classification_colorramps_get, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_set, METH_VARARGS, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_get", _wrap_Dwg_Object_POINTCLOUDCOLORMAP_classification_colorramps_get, METH_O, NULL},
	 { "new_Dwg_Object_POINTCLOUDCOLORMAP", _wrap_new_Dwg_Object_POINTCLOUDCOLORMAP, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_POINTCLOUDCOLORMAP", _wrap_delete_Dwg_Object_POINTCLOUDCOLORMAP, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_swigregister", Dwg_Object_POINTCLOUDCOLORMAP_swigregister, METH_O, NULL},
	 { "Dwg_Object_POINTCLOUDCOLORMAP_swiginit", Dwg_Object_POINTCLOUDCOLORMAP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_COMPOUNDOBJECTID_parent_set", _wrap_Dwg_COMPOUNDOBJECTID_parent_set, METH_VARARGS, NULL},
	 { "Dwg_COMPOUNDOBJECTID_parent_get", _wrap_Dwg_COMPOUNDOBJECTID_parent_get, METH_O, NULL},
	 { "Dwg_COMPOUNDOBJECTID_has_object_set", _wrap_Dwg_COMPOUNDOBJECTID_has_object_set, METH_VARARGS, NULL},
	 { "Dwg_COMPOUNDOBJECTID_has_object_get", _wrap_Dwg_COMPOUNDOBJECTID_has_object_get, METH_O, NULL},
	 { "Dwg_COMPOUNDOBJECTID_name_set", _wrap_Dwg_COMPOUNDOBJECTID_name_set, METH_VARARGS, NULL},
	 { "Dwg_COMPOUNDOBJECTID_name_get", _wrap_Dwg_COMPOUNDOBJECTID_name_get, METH_O, NULL},
	 { "Dwg_COMPOUNDOBJECTID_object_set", _wrap_Dwg_COMPOUNDOBJECTID_object_set, METH_VARARGS, NULL},
	 { "Dwg_COMPOUNDOBJECTID_object_get", _wrap_Dwg_COMPOUNDOBJECTID_object_get, METH_O, NULL},
	 { "new_Dwg_COMPOUNDOBJECTID", _wrap_new_Dwg_COMPOUNDOBJECTID, METH_NOARGS, NULL},
	 { "delete_Dwg_COMPOUNDOBJECTID", _wrap_delete_Dwg_COMPOUNDOBJECTID, METH_O, NULL},
	 { "Dwg_COMPOUNDOBJECTID_swigregister", Dwg_COMPOUNDOBJECTID_swigregister, METH_O, NULL},
	 { "Dwg_COMPOUNDOBJECTID_swiginit", Dwg_COMPOUNDOBJECTID_swiginit, METH_VARARGS, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_set, METH_VARARGS, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_get", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_parent_get, METH_O, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_set, METH_VARARGS, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_get", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_min_get, METH_O, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_set, METH_VARARGS, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_get", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_extents_max_get, METH_O, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_object_set, METH_VARARGS, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_object_get", _wrap_Dwg_PARTIAL_VIEWING_INDEX_Entry_object_get, METH_O, NULL},
	 { "new_Dwg_PARTIAL_VIEWING_INDEX_Entry", _wrap_new_Dwg_PARTIAL_VIEWING_INDEX_Entry, METH_NOARGS, NULL},
	 { "delete_Dwg_PARTIAL_VIEWING_INDEX_Entry", _wrap_delete_Dwg_PARTIAL_VIEWING_INDEX_Entry, METH_O, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_swigregister", Dwg_PARTIAL_VIEWING_INDEX_Entry_swigregister, METH_O, NULL},
	 { "Dwg_PARTIAL_VIEWING_INDEX_Entry_swiginit", Dwg_PARTIAL_VIEWING_INDEX_Entry_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_parent_get", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_parent_get, METH_O, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_get", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_num_entries_get, METH_O, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_get", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_has_entries_get, METH_O, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_entries_set, METH_VARARGS, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_entries_get", _wrap_Dwg_Object_PARTIAL_VIEWING_INDEX_entries_get, METH_O, NULL},
	 { "new_Dwg_Object_PARTIAL_VIEWING_INDEX", _wrap_new_Dwg_Object_PARTIAL_VIEWING_INDEX, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_PARTIAL_VIEWING_INDEX", _wrap_delete_Dwg_Object_PARTIAL_VIEWING_INDEX, METH_O, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_swigregister", Dwg_Object_PARTIAL_VIEWING_INDEX_swigregister, METH_O, NULL},
	 { "Dwg_Object_PARTIAL_VIEWING_INDEX_swiginit", Dwg_Object_PARTIAL_VIEWING_INDEX_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNKNOWN_ENT_parent_set", _wrap_Dwg_Entity_UNKNOWN_ENT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_UNKNOWN_ENT_parent_get", _wrap_Dwg_Entity_UNKNOWN_ENT_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_UNKNOWN_ENT", _wrap_new_Dwg_Entity_UNKNOWN_ENT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_UNKNOWN_ENT", _wrap_delete_Dwg_Entity_UNKNOWN_ENT, METH_O, NULL},
	 { "Dwg_Entity_UNKNOWN_ENT_swigregister", Dwg_Entity_UNKNOWN_ENT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_UNKNOWN_ENT_swiginit", Dwg_Entity_UNKNOWN_ENT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_UNKNOWN_OBJ_parent_set", _wrap_Dwg_Object_UNKNOWN_OBJ_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_UNKNOWN_OBJ_parent_get", _wrap_Dwg_Object_UNKNOWN_OBJ_parent_get, METH_O, NULL},
	 { "new_Dwg_Object_UNKNOWN_OBJ", _wrap_new_Dwg_Object_UNKNOWN_OBJ, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_UNKNOWN_OBJ", _wrap_delete_Dwg_Object_UNKNOWN_OBJ, METH_O, NULL},
	 { "Dwg_Object_UNKNOWN_OBJ_swigregister", Dwg_Object_UNKNOWN_OBJ_swigregister, METH_O, NULL},
	 { "Dwg_Object_UNKNOWN_OBJ_swiginit", Dwg_Object_UNKNOWN_OBJ_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_REPEAT_parent_set", _wrap_Dwg_Entity_REPEAT_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_REPEAT_parent_get", _wrap_Dwg_Entity_REPEAT_parent_get, METH_O, NULL},
	 { "new_Dwg_Entity_REPEAT", _wrap_new_Dwg_Entity_REPEAT, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_REPEAT", _wrap_delete_Dwg_Entity_REPEAT, METH_O, NULL},
	 { "Dwg_Entity_REPEAT_swigregister", Dwg_Entity_REPEAT_swigregister, METH_O, NULL},
	 { "Dwg_Entity_REPEAT_swiginit", Dwg_Entity_REPEAT_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_parent_set", _wrap_Dwg_Entity_ENDREP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_parent_get", _wrap_Dwg_Entity_ENDREP_parent_get, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_numcols_set", _wrap_Dwg_Entity_ENDREP_numcols_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_numcols_get", _wrap_Dwg_Entity_ENDREP_numcols_get, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_numrows_set", _wrap_Dwg_Entity_ENDREP_numrows_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_numrows_get", _wrap_Dwg_Entity_ENDREP_numrows_get, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_colspacing_set", _wrap_Dwg_Entity_ENDREP_colspacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_colspacing_get", _wrap_Dwg_Entity_ENDREP_colspacing_get, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_rowspacing_set", _wrap_Dwg_Entity_ENDREP_rowspacing_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_ENDREP_rowspacing_get", _wrap_Dwg_Entity_ENDREP_rowspacing_get, METH_O, NULL},
	 { "new_Dwg_Entity_ENDREP", _wrap_new_Dwg_Entity_ENDREP, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_ENDREP", _wrap_delete_Dwg_Entity_ENDREP, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_swigregister", Dwg_Entity_ENDREP_swigregister, METH_O, NULL},
	 { "Dwg_Entity_ENDREP_swiginit", Dwg_Entity_ENDREP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOAD_parent_set", _wrap_Dwg_Entity_LOAD_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOAD_parent_get", _wrap_Dwg_Entity_LOAD_parent_get, METH_O, NULL},
	 { "Dwg_Entity_LOAD_file_name_set", _wrap_Dwg_Entity_LOAD_file_name_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_LOAD_file_name_get", _wrap_Dwg_Entity_LOAD_file_name_get, METH_O, NULL},
	 { "new_Dwg_Entity_LOAD", _wrap_new_Dwg_Entity_LOAD, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_LOAD", _wrap_delete_Dwg_Entity_LOAD, METH_O, NULL},
	 { "Dwg_Entity_LOAD_swigregister", Dwg_Entity_LOAD_swigregister, METH_O, NULL},
	 { "Dwg_Entity_LOAD_swiginit", Dwg_Entity_LOAD_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity_JUMP_parent_set", _wrap_Dwg_Entity_JUMP_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_JUMP_parent_get", _wrap_Dwg_Entity_JUMP_parent_get, METH_O, NULL},
	 { "Dwg_Entity_JUMP_jump_address_raw_set", _wrap_Dwg_Entity_JUMP_jump_address_raw_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_JUMP_jump_address_raw_get", _wrap_Dwg_Entity_JUMP_jump_address_raw_get, METH_O, NULL},
	 { "Dwg_Entity_JUMP_jump_address_set", _wrap_Dwg_Entity_JUMP_jump_address_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_JUMP_jump_address_get", _wrap_Dwg_Entity_JUMP_jump_address_get, METH_O, NULL},
	 { "Dwg_Entity_JUMP_jump_entity_section_set", _wrap_Dwg_Entity_JUMP_jump_entity_section_set, METH_VARARGS, NULL},
	 { "Dwg_Entity_JUMP_jump_entity_section_get", _wrap_Dwg_Entity_JUMP_jump_entity_section_get, METH_O, NULL},
	 { "new_Dwg_Entity_JUMP", _wrap_new_Dwg_Entity_JUMP, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity_JUMP", _wrap_delete_Dwg_Entity_JUMP, METH_O, NULL},
	 { "Dwg_Entity_JUMP_swigregister", Dwg_Entity_JUMP_swigregister, METH_O, NULL},
	 { "Dwg_Entity_JUMP_swiginit", Dwg_Entity_JUMP_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_parent_set", _wrap_Dwg_Entity__3DLINE_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_parent_get", _wrap_Dwg_Entity__3DLINE_parent_get, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_start_set", _wrap_Dwg_Entity__3DLINE_start_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_start_get", _wrap_Dwg_Entity__3DLINE_start_get, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_end_set", _wrap_Dwg_Entity__3DLINE_end_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_end_get", _wrap_Dwg_Entity__3DLINE_end_get, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_extrusion_set", _wrap_Dwg_Entity__3DLINE_extrusion_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_extrusion_get", _wrap_Dwg_Entity__3DLINE_extrusion_get, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_thickness_set", _wrap_Dwg_Entity__3DLINE_thickness_set, METH_VARARGS, NULL},
	 { "Dwg_Entity__3DLINE_thickness_get", _wrap_Dwg_Entity__3DLINE_thickness_get, METH_O, NULL},
	 { "new_Dwg_Entity__3DLINE", _wrap_new_Dwg_Entity__3DLINE, METH_NOARGS, NULL},
	 { "delete_Dwg_Entity__3DLINE", _wrap_delete_Dwg_Entity__3DLINE, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_swigregister", Dwg_Entity__3DLINE_swigregister, METH_O, NULL},
	 { "Dwg_Entity__3DLINE_swiginit", Dwg_Entity__3DLINE_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Eed_Data_u_set", _wrap_Dwg_Eed_Data_u_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_Data_u_get", _wrap_Dwg_Eed_Data_u_get, METH_O, NULL},
	 { "Dwg_Eed_Data_code_set", _wrap_Dwg_Eed_Data_code_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_Data_code_get", _wrap_Dwg_Eed_Data_code_get, METH_O, NULL},
	 { "new_Dwg_Eed_Data", _wrap_new_Dwg_Eed_Data, METH_NOARGS, NULL},
	 { "delete_Dwg_Eed_Data", _wrap_delete_Dwg_Eed_Data, METH_O, NULL},
	 { "Dwg_Eed_Data_swigregister", Dwg_Eed_Data_swigregister, METH_O, NULL},
	 { "Dwg_Eed_Data_swiginit", Dwg_Eed_Data_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_get", _wrap_eed_data_t_eed_0_get, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007_get", _wrap_eed_data_t_eed_0_r2007_get, METH_O, NULL},
	 { "eed_data_t_eed_1_get", _wrap_eed_data_t_eed_1_get, METH_O, NULL},
	 { "eed_data_t_eed_2_get", _wrap_eed_data_t_eed_2_get, METH_O, NULL},
	 { "eed_data_t_eed_3_get", _wrap_eed_data_t_eed_3_get, METH_O, NULL},
	 { "eed_data_t_eed_4_get", _wrap_eed_data_t_eed_4_get, METH_O, NULL},
	 { "eed_data_t_eed_5_get", _wrap_eed_data_t_eed_5_get, METH_O, NULL},
	 { "eed_data_t_eed_10_get", _wrap_eed_data_t_eed_10_get, METH_O, NULL},
	 { "eed_data_t_eed_40_get", _wrap_eed_data_t_eed_40_get, METH_O, NULL},
	 { "eed_data_t_eed_70_get", _wrap_eed_data_t_eed_70_get, METH_O, NULL},
	 { "eed_data_t_eed_71_get", _wrap_eed_data_t_eed_71_get, METH_O, NULL},
	 { "new_eed_data_t", _wrap_new_eed_data_t, METH_NOARGS, NULL},
	 { "delete_eed_data_t", _wrap_delete_eed_data_t, METH_O, NULL},
	 { "eed_data_t_swigregister", eed_data_t_swigregister, METH_O, NULL},
	 { "eed_data_t_swiginit", eed_data_t_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_71_rl_set", _wrap_eed_data_t_eed_71_rl_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_71_rl_get", _wrap_eed_data_t_eed_71_rl_get, METH_O, NULL},
	 { "new_eed_data_t_eed_71", _wrap_new_eed_data_t_eed_71, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_71", _wrap_delete_eed_data_t_eed_71, METH_O, NULL},
	 { "eed_data_t_eed_71_swigregister", eed_data_t_eed_71_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_71_swiginit", eed_data_t_eed_71_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_70_rs_set", _wrap_eed_data_t_eed_70_rs_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_70_rs_get", _wrap_eed_data_t_eed_70_rs_get, METH_O, NULL},
	 { "new_eed_data_t_eed_70", _wrap_new_eed_data_t_eed_70, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_70", _wrap_delete_eed_data_t_eed_70, METH_O, NULL},
	 { "eed_data_t_eed_70_swigregister", eed_data_t_eed_70_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_70_swiginit", eed_data_t_eed_70_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_40_real_set", _wrap_eed_data_t_eed_40_real_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_40_real_get", _wrap_eed_data_t_eed_40_real_get, METH_O, NULL},
	 { "new_eed_data_t_eed_40", _wrap_new_eed_data_t_eed_40, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_40", _wrap_delete_eed_data_t_eed_40, METH_O, NULL},
	 { "eed_data_t_eed_40_swigregister", eed_data_t_eed_40_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_40_swiginit", eed_data_t_eed_40_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_10_point_set", _wrap_eed_data_t_eed_10_point_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_10_point_get", _wrap_eed_data_t_eed_10_point_get, METH_O, NULL},
	 { "new_eed_data_t_eed_10", _wrap_new_eed_data_t_eed_10, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_10", _wrap_delete_eed_data_t_eed_10, METH_O, NULL},
	 { "eed_data_t_eed_10_swigregister", eed_data_t_eed_10_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_10_swiginit", eed_data_t_eed_10_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_5_entity_set", _wrap_eed_data_t_eed_5_entity_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_5_entity_get", _wrap_eed_data_t_eed_5_entity_get, METH_O, NULL},
	 { "new_eed_data_t_eed_5", _wrap_new_eed_data_t_eed_5, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_5", _wrap_delete_eed_data_t_eed_5, METH_O, NULL},
	 { "eed_data_t_eed_5_swigregister", eed_data_t_eed_5_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_5_swiginit", eed_data_t_eed_5_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_4_length_set", _wrap_eed_data_t_eed_4_length_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_4_length_get", _wrap_eed_data_t_eed_4_length_get, METH_O, NULL},
	 { "eed_data_t_eed_4_data_get", _wrap_eed_data_t_eed_4_data_get, METH_O, NULL},
	 { "new_eed_data_t_eed_4", _wrap_new_eed_data_t_eed_4, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_4", _wrap_delete_eed_data_t_eed_4, METH_O, NULL},
	 { "eed_data_t_eed_4_swigregister", eed_data_t_eed_4_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_4_swiginit", eed_data_t_eed_4_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_3_layer_set", _wrap_eed_data_t_eed_3_layer_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_3_layer_get", _wrap_eed_data_t_eed_3_layer_get, METH_O, NULL},
	 { "new_eed_data_t_eed_3", _wrap_new_eed_data_t_eed_3, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_3", _wrap_delete_eed_data_t_eed_3, METH_O, NULL},
	 { "eed_data_t_eed_3_swigregister", eed_data_t_eed_3_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_3_swiginit", eed_data_t_eed_3_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_2_close_set", _wrap_eed_data_t_eed_2_close_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_2_close_get", _wrap_eed_data_t_eed_2_close_get, METH_O, NULL},
	 { "new_eed_data_t_eed_2", _wrap_new_eed_data_t_eed_2, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_2", _wrap_delete_eed_data_t_eed_2, METH_O, NULL},
	 { "eed_data_t_eed_2_swigregister", eed_data_t_eed_2_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_2_swiginit", eed_data_t_eed_2_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_1_appid_index_set", _wrap_eed_data_t_eed_1_appid_index_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_1_appid_index_get", _wrap_eed_data_t_eed_1_appid_index_get, METH_O, NULL},
	 { "eed_data_t_eed_1_invalid_set", _wrap_eed_data_t_eed_1_invalid_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_1_invalid_get", _wrap_eed_data_t_eed_1_invalid_get, METH_O, NULL},
	 { "new_eed_data_t_eed_1", _wrap_new_eed_data_t_eed_1, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_1", _wrap_delete_eed_data_t_eed_1, METH_O, NULL},
	 { "eed_data_t_eed_1_swigregister", eed_data_t_eed_1_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_1_swiginit", eed_data_t_eed_1_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_r2007_length_set", _wrap_eed_data_t_eed_0_r2007_length_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_r2007_length_get", _wrap_eed_data_t_eed_0_r2007_length_get, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007__padding_set", _wrap_eed_data_t_eed_0_r2007__padding_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_r2007__padding_get", _wrap_eed_data_t_eed_0_r2007__padding_get, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007_is_tu_set", _wrap_eed_data_t_eed_0_r2007_is_tu_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_r2007_is_tu_get", _wrap_eed_data_t_eed_0_r2007_is_tu_get, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007_string_set", _wrap_eed_data_t_eed_0_r2007_string_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_r2007_string_get", _wrap_eed_data_t_eed_0_r2007_string_get, METH_O, NULL},
	 { "new_eed_data_t_eed_0_r2007", _wrap_new_eed_data_t_eed_0_r2007, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_0_r2007", _wrap_delete_eed_data_t_eed_0_r2007, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007_swigregister", eed_data_t_eed_0_r2007_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_0_r2007_swiginit", eed_data_t_eed_0_r2007_swiginit, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_length_set", _wrap_eed_data_t_eed_0_length_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_length_get", _wrap_eed_data_t_eed_0_length_get, METH_O, NULL},
	 { "eed_data_t_eed_0_codepage_set", _wrap_eed_data_t_eed_0_codepage_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_codepage_get", _wrap_eed_data_t_eed_0_codepage_get, METH_O, NULL},
	 { "eed_data_t_eed_0_is_tu_set", _wrap_eed_data_t_eed_0_is_tu_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_is_tu_get", _wrap_eed_data_t_eed_0_is_tu_get, METH_O, NULL},
	 { "eed_data_t_eed_0_string_set", _wrap_eed_data_t_eed_0_string_set, METH_VARARGS, NULL},
	 { "eed_data_t_eed_0_string_get", _wrap_eed_data_t_eed_0_string_get, METH_O, NULL},
	 { "new_eed_data_t_eed_0", _wrap_new_eed_data_t_eed_0, METH_NOARGS, NULL},
	 { "delete_eed_data_t_eed_0", _wrap_delete_eed_data_t_eed_0, METH_O, NULL},
	 { "eed_data_t_eed_0_swigregister", eed_data_t_eed_0_swigregister, METH_O, NULL},
	 { "eed_data_t_eed_0_swiginit", eed_data_t_eed_0_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Eed_size_set", _wrap_Dwg_Eed_size_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_size_get", _wrap_Dwg_Eed_size_get, METH_O, NULL},
	 { "Dwg_Eed_handle_set", _wrap_Dwg_Eed_handle_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_handle_get", _wrap_Dwg_Eed_handle_get, METH_O, NULL},
	 { "Dwg_Eed_data_set", _wrap_Dwg_Eed_data_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_data_get", _wrap_Dwg_Eed_data_get, METH_O, NULL},
	 { "Dwg_Eed_raw_set", _wrap_Dwg_Eed_raw_set, METH_VARARGS, NULL},
	 { "Dwg_Eed_raw_get", _wrap_Dwg_Eed_raw_get, METH_O, NULL},
	 { "new_Dwg_Eed", _wrap_new_Dwg_Eed, METH_NOARGS, NULL},
	 { "delete_Dwg_Eed", _wrap_delete_Dwg_Eed, METH_O, NULL},
	 { "Dwg_Eed_swigregister", Dwg_Eed_swigregister, METH_O, NULL},
	 { "Dwg_Eed_swiginit", Dwg_Eed_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_objid_set", _wrap_Dwg_Object_Entity_objid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_objid_get", _wrap_Dwg_Object_Entity_objid_get, METH_O, NULL},
	 { "Dwg_Object_Entity_tio_get", _wrap_Dwg_Object_Entity_tio_get, METH_O, NULL},
	 { "Dwg_Object_Entity_dwg_set", _wrap_Dwg_Object_Entity_dwg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_dwg_get", _wrap_Dwg_Object_Entity_dwg_get, METH_O, NULL},
	 { "Dwg_Object_Entity_num_eed_set", _wrap_Dwg_Object_Entity_num_eed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_num_eed_get", _wrap_Dwg_Object_Entity_num_eed_get, METH_O, NULL},
	 { "Dwg_Object_Entity_eed_set", _wrap_Dwg_Object_Entity_eed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_eed_get", _wrap_Dwg_Object_Entity_eed_get, METH_O, NULL},
	 { "Dwg_Object_Entity_preview_exists_set", _wrap_Dwg_Object_Entity_preview_exists_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_preview_exists_get", _wrap_Dwg_Object_Entity_preview_exists_get, METH_O, NULL},
	 { "Dwg_Object_Entity_preview_is_proxy_set", _wrap_Dwg_Object_Entity_preview_is_proxy_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_preview_is_proxy_get", _wrap_Dwg_Object_Entity_preview_is_proxy_get, METH_O, NULL},
	 { "Dwg_Object_Entity_preview_size_set", _wrap_Dwg_Object_Entity_preview_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_preview_size_get", _wrap_Dwg_Object_Entity_preview_size_get, METH_O, NULL},
	 { "Dwg_Object_Entity_preview_set", _wrap_Dwg_Object_Entity_preview_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_preview_get", _wrap_Dwg_Object_Entity_preview_get, METH_O, NULL},
	 { "Dwg_Object_Entity_entmode_set", _wrap_Dwg_Object_Entity_entmode_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_entmode_get", _wrap_Dwg_Object_Entity_entmode_get, METH_O, NULL},
	 { "Dwg_Object_Entity_num_reactors_set", _wrap_Dwg_Object_Entity_num_reactors_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_num_reactors_get", _wrap_Dwg_Object_Entity_num_reactors_get, METH_O, NULL},
	 { "Dwg_Object_Entity_is_xdic_missing_set", _wrap_Dwg_Object_Entity_is_xdic_missing_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_is_xdic_missing_get", _wrap_Dwg_Object_Entity_is_xdic_missing_get, METH_O, NULL},
	 { "Dwg_Object_Entity_isbylayerlt_set", _wrap_Dwg_Object_Entity_isbylayerlt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_isbylayerlt_get", _wrap_Dwg_Object_Entity_isbylayerlt_get, METH_O, NULL},
	 { "Dwg_Object_Entity_nolinks_set", _wrap_Dwg_Object_Entity_nolinks_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_nolinks_get", _wrap_Dwg_Object_Entity_nolinks_get, METH_O, NULL},
	 { "Dwg_Object_Entity_has_ds_data_set", _wrap_Dwg_Object_Entity_has_ds_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_has_ds_data_get", _wrap_Dwg_Object_Entity_has_ds_data_get, METH_O, NULL},
	 { "Dwg_Object_Entity_color_set", _wrap_Dwg_Object_Entity_color_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_color_get", _wrap_Dwg_Object_Entity_color_get, METH_O, NULL},
	 { "Dwg_Object_Entity_ltype_scale_set", _wrap_Dwg_Object_Entity_ltype_scale_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_ltype_scale_get", _wrap_Dwg_Object_Entity_ltype_scale_get, METH_O, NULL},
	 { "Dwg_Object_Entity_ltype_flags_set", _wrap_Dwg_Object_Entity_ltype_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_ltype_flags_get", _wrap_Dwg_Object_Entity_ltype_flags_get, METH_O, NULL},
	 { "Dwg_Object_Entity_plotstyle_flags_set", _wrap_Dwg_Object_Entity_plotstyle_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_plotstyle_flags_get", _wrap_Dwg_Object_Entity_plotstyle_flags_get, METH_O, NULL},
	 { "Dwg_Object_Entity_material_flags_set", _wrap_Dwg_Object_Entity_material_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_material_flags_get", _wrap_Dwg_Object_Entity_material_flags_get, METH_O, NULL},
	 { "Dwg_Object_Entity_shadow_flags_set", _wrap_Dwg_Object_Entity_shadow_flags_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_shadow_flags_get", _wrap_Dwg_Object_Entity_shadow_flags_get, METH_O, NULL},
	 { "Dwg_Object_Entity_has_full_visualstyle_set", _wrap_Dwg_Object_Entity_has_full_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_has_full_visualstyle_get", _wrap_Dwg_Object_Entity_has_full_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_has_face_visualstyle_set", _wrap_Dwg_Object_Entity_has_face_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_has_face_visualstyle_get", _wrap_Dwg_Object_Entity_has_face_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_has_edge_visualstyle_set", _wrap_Dwg_Object_Entity_has_edge_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_has_edge_visualstyle_get", _wrap_Dwg_Object_Entity_has_edge_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_invisible_set", _wrap_Dwg_Object_Entity_invisible_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_invisible_get", _wrap_Dwg_Object_Entity_invisible_get, METH_O, NULL},
	 { "Dwg_Object_Entity_linewt_set", _wrap_Dwg_Object_Entity_linewt_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_linewt_get", _wrap_Dwg_Object_Entity_linewt_get, METH_O, NULL},
	 { "Dwg_Object_Entity_flag_r11_set", _wrap_Dwg_Object_Entity_flag_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_flag_r11_get", _wrap_Dwg_Object_Entity_flag_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_opts_r11_set", _wrap_Dwg_Object_Entity_opts_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_opts_r11_get", _wrap_Dwg_Object_Entity_opts_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_extra_r11_set", _wrap_Dwg_Object_Entity_extra_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_extra_r11_get", _wrap_Dwg_Object_Entity_extra_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_color_r11_set", _wrap_Dwg_Object_Entity_color_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_color_r11_get", _wrap_Dwg_Object_Entity_color_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_elevation_r11_set", _wrap_Dwg_Object_Entity_elevation_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_elevation_r11_get", _wrap_Dwg_Object_Entity_elevation_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_thickness_r11_set", _wrap_Dwg_Object_Entity_thickness_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_thickness_r11_get", _wrap_Dwg_Object_Entity_thickness_r11_get, METH_O, NULL},
	 { "Dwg_Object_Entity_viewport_set", _wrap_Dwg_Object_Entity_viewport_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_viewport_get", _wrap_Dwg_Object_Entity_viewport_get, METH_O, NULL},
	 { "Dwg_Object_Entity___iterator_set", _wrap_Dwg_Object_Entity___iterator_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity___iterator_get", _wrap_Dwg_Object_Entity___iterator_get, METH_O, NULL},
	 { "Dwg_Object_Entity_ownerhandle_set", _wrap_Dwg_Object_Entity_ownerhandle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_ownerhandle_get", _wrap_Dwg_Object_Entity_ownerhandle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_reactors_set", _wrap_Dwg_Object_Entity_reactors_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_reactors_get", _wrap_Dwg_Object_Entity_reactors_get, METH_O, NULL},
	 { "Dwg_Object_Entity_xdicobjhandle_set", _wrap_Dwg_Object_Entity_xdicobjhandle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_xdicobjhandle_get", _wrap_Dwg_Object_Entity_xdicobjhandle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_prev_entity_set", _wrap_Dwg_Object_Entity_prev_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_prev_entity_get", _wrap_Dwg_Object_Entity_prev_entity_get, METH_O, NULL},
	 { "Dwg_Object_Entity_next_entity_set", _wrap_Dwg_Object_Entity_next_entity_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_next_entity_get", _wrap_Dwg_Object_Entity_next_entity_get, METH_O, NULL},
	 { "Dwg_Object_Entity_layer_set", _wrap_Dwg_Object_Entity_layer_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_layer_get", _wrap_Dwg_Object_Entity_layer_get, METH_O, NULL},
	 { "Dwg_Object_Entity_ltype_set", _wrap_Dwg_Object_Entity_ltype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_ltype_get", _wrap_Dwg_Object_Entity_ltype_get, METH_O, NULL},
	 { "Dwg_Object_Entity_material_set", _wrap_Dwg_Object_Entity_material_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_material_get", _wrap_Dwg_Object_Entity_material_get, METH_O, NULL},
	 { "Dwg_Object_Entity_shadow_set", _wrap_Dwg_Object_Entity_shadow_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_shadow_get", _wrap_Dwg_Object_Entity_shadow_get, METH_O, NULL},
	 { "Dwg_Object_Entity_plotstyle_set", _wrap_Dwg_Object_Entity_plotstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_plotstyle_get", _wrap_Dwg_Object_Entity_plotstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_full_visualstyle_set", _wrap_Dwg_Object_Entity_full_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_full_visualstyle_get", _wrap_Dwg_Object_Entity_full_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_face_visualstyle_set", _wrap_Dwg_Object_Entity_face_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_face_visualstyle_get", _wrap_Dwg_Object_Entity_face_visualstyle_get, METH_O, NULL},
	 { "Dwg_Object_Entity_edge_visualstyle_set", _wrap_Dwg_Object_Entity_edge_visualstyle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Entity_edge_visualstyle_get", _wrap_Dwg_Object_Entity_edge_visualstyle_get, METH_O, NULL},
	 { "new_Dwg_Object_Entity", _wrap_new_Dwg_Object_Entity, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_Entity", _wrap_delete_Dwg_Object_Entity, METH_O, NULL},
	 { "Dwg_Object_Entity_swigregister", Dwg_Object_Entity_swigregister, METH_O, NULL},
	 { "Dwg_Object_Entity_swiginit", Dwg_Object_Entity_swiginit, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_UNUSED_set", _wrap__dwg_object_entity_tio_UNUSED_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_UNUSED_get", _wrap__dwg_object_entity_tio_UNUSED_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_common_set", _wrap__dwg_object_entity_tio_DIMENSION_common_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_common_get", _wrap__dwg_object_entity_tio_DIMENSION_common_get, METH_O, NULL},
	 { "_dwg_object_entity_tio__3DFACE_set", _wrap__dwg_object_entity_tio__3DFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio__3DFACE_get", _wrap__dwg_object_entity_tio__3DFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio__3DSOLID_set", _wrap__dwg_object_entity_tio__3DSOLID_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio__3DSOLID_get", _wrap__dwg_object_entity_tio__3DSOLID_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ARC_set", _wrap__dwg_object_entity_tio_ARC_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ARC_get", _wrap__dwg_object_entity_tio_ARC_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ATTDEF_set", _wrap__dwg_object_entity_tio_ATTDEF_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ATTDEF_get", _wrap__dwg_object_entity_tio_ATTDEF_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ATTRIB_set", _wrap__dwg_object_entity_tio_ATTRIB_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ATTRIB_get", _wrap__dwg_object_entity_tio_ATTRIB_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_BLOCK_set", _wrap__dwg_object_entity_tio_BLOCK_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_BLOCK_get", _wrap__dwg_object_entity_tio_BLOCK_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_BODY_set", _wrap__dwg_object_entity_tio_BODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_BODY_get", _wrap__dwg_object_entity_tio_BODY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_CIRCLE_set", _wrap__dwg_object_entity_tio_CIRCLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_CIRCLE_get", _wrap__dwg_object_entity_tio_CIRCLE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ALIGNED_set", _wrap__dwg_object_entity_tio_DIMENSION_ALIGNED_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ALIGNED_get", _wrap__dwg_object_entity_tio_DIMENSION_ALIGNED_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ANG2LN_set", _wrap__dwg_object_entity_tio_DIMENSION_ANG2LN_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ANG2LN_get", _wrap__dwg_object_entity_tio_DIMENSION_ANG2LN_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ANG3PT_set", _wrap__dwg_object_entity_tio_DIMENSION_ANG3PT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ANG3PT_get", _wrap__dwg_object_entity_tio_DIMENSION_ANG3PT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_DIAMETER_set", _wrap__dwg_object_entity_tio_DIMENSION_DIAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_DIAMETER_get", _wrap__dwg_object_entity_tio_DIMENSION_DIAMETER_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_LINEAR_set", _wrap__dwg_object_entity_tio_DIMENSION_LINEAR_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_LINEAR_get", _wrap__dwg_object_entity_tio_DIMENSION_LINEAR_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ORDINATE_set", _wrap__dwg_object_entity_tio_DIMENSION_ORDINATE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_ORDINATE_get", _wrap__dwg_object_entity_tio_DIMENSION_ORDINATE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_RADIUS_set", _wrap__dwg_object_entity_tio_DIMENSION_RADIUS_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DIMENSION_RADIUS_get", _wrap__dwg_object_entity_tio_DIMENSION_RADIUS_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ELLIPSE_set", _wrap__dwg_object_entity_tio_ELLIPSE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ELLIPSE_get", _wrap__dwg_object_entity_tio_ELLIPSE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ENDBLK_set", _wrap__dwg_object_entity_tio_ENDBLK_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ENDBLK_get", _wrap__dwg_object_entity_tio_ENDBLK_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_INSERT_set", _wrap__dwg_object_entity_tio_INSERT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_INSERT_get", _wrap__dwg_object_entity_tio_INSERT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LEADER_set", _wrap__dwg_object_entity_tio_LEADER_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LEADER_get", _wrap__dwg_object_entity_tio_LEADER_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LINE_set", _wrap__dwg_object_entity_tio_LINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LINE_get", _wrap__dwg_object_entity_tio_LINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LOAD_set", _wrap__dwg_object_entity_tio_LOAD_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LOAD_get", _wrap__dwg_object_entity_tio_LOAD_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MINSERT_set", _wrap__dwg_object_entity_tio_MINSERT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MINSERT_get", _wrap__dwg_object_entity_tio_MINSERT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MLINE_set", _wrap__dwg_object_entity_tio_MLINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MLINE_get", _wrap__dwg_object_entity_tio_MLINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MTEXT_set", _wrap__dwg_object_entity_tio_MTEXT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MTEXT_get", _wrap__dwg_object_entity_tio_MTEXT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_OLEFRAME_set", _wrap__dwg_object_entity_tio_OLEFRAME_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_OLEFRAME_get", _wrap__dwg_object_entity_tio_OLEFRAME_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POINT_set", _wrap__dwg_object_entity_tio_POINT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POINT_get", _wrap__dwg_object_entity_tio_POINT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_2D_set", _wrap__dwg_object_entity_tio_POLYLINE_2D_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_2D_get", _wrap__dwg_object_entity_tio_POLYLINE_2D_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_3D_set", _wrap__dwg_object_entity_tio_POLYLINE_3D_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_3D_get", _wrap__dwg_object_entity_tio_POLYLINE_3D_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_MESH_set", _wrap__dwg_object_entity_tio_POLYLINE_MESH_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_MESH_get", _wrap__dwg_object_entity_tio_POLYLINE_MESH_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_PFACE_set", _wrap__dwg_object_entity_tio_POLYLINE_PFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POLYLINE_PFACE_get", _wrap__dwg_object_entity_tio_POLYLINE_PFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_PROXY_ENTITY_set", _wrap__dwg_object_entity_tio_PROXY_ENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_PROXY_ENTITY_get", _wrap__dwg_object_entity_tio_PROXY_ENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_RAY_set", _wrap__dwg_object_entity_tio_RAY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_RAY_get", _wrap__dwg_object_entity_tio_RAY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_REGION_set", _wrap__dwg_object_entity_tio_REGION_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_REGION_get", _wrap__dwg_object_entity_tio_REGION_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SEQEND_set", _wrap__dwg_object_entity_tio_SEQEND_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SEQEND_get", _wrap__dwg_object_entity_tio_SEQEND_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SHAPE_set", _wrap__dwg_object_entity_tio_SHAPE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SHAPE_get", _wrap__dwg_object_entity_tio_SHAPE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SOLID_set", _wrap__dwg_object_entity_tio_SOLID_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SOLID_get", _wrap__dwg_object_entity_tio_SOLID_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SPLINE_set", _wrap__dwg_object_entity_tio_SPLINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SPLINE_get", _wrap__dwg_object_entity_tio_SPLINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_TEXT_set", _wrap__dwg_object_entity_tio_TEXT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_TEXT_get", _wrap__dwg_object_entity_tio_TEXT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_TOLERANCE_set", _wrap__dwg_object_entity_tio_TOLERANCE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_TOLERANCE_get", _wrap__dwg_object_entity_tio_TOLERANCE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_TRACE_set", _wrap__dwg_object_entity_tio_TRACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_TRACE_get", _wrap__dwg_object_entity_tio_TRACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_UNKNOWN_ENT_set", _wrap__dwg_object_entity_tio_UNKNOWN_ENT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_UNKNOWN_ENT_get", _wrap__dwg_object_entity_tio_UNKNOWN_ENT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VERTEX_2D_set", _wrap__dwg_object_entity_tio_VERTEX_2D_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VERTEX_2D_get", _wrap__dwg_object_entity_tio_VERTEX_2D_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VERTEX_3D_set", _wrap__dwg_object_entity_tio_VERTEX_3D_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VERTEX_3D_get", _wrap__dwg_object_entity_tio_VERTEX_3D_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VERTEX_MESH_set", _wrap__dwg_object_entity_tio_VERTEX_MESH_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VERTEX_MESH_get", _wrap__dwg_object_entity_tio_VERTEX_MESH_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VERTEX_PFACE_set", _wrap__dwg_object_entity_tio_VERTEX_PFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VERTEX_PFACE_get", _wrap__dwg_object_entity_tio_VERTEX_PFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VERTEX_PFACE_FACE_set", _wrap__dwg_object_entity_tio_VERTEX_PFACE_FACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VERTEX_PFACE_FACE_get", _wrap__dwg_object_entity_tio_VERTEX_PFACE_FACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VIEWPORT_set", _wrap__dwg_object_entity_tio_VIEWPORT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VIEWPORT_get", _wrap__dwg_object_entity_tio_VIEWPORT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_XLINE_set", _wrap__dwg_object_entity_tio_XLINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_XLINE_get", _wrap__dwg_object_entity_tio_XLINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio__3DLINE_set", _wrap__dwg_object_entity_tio__3DLINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio__3DLINE_get", _wrap__dwg_object_entity_tio__3DLINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_CAMERA_set", _wrap__dwg_object_entity_tio_CAMERA_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_CAMERA_get", _wrap__dwg_object_entity_tio_CAMERA_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DGNUNDERLAY_set", _wrap__dwg_object_entity_tio_DGNUNDERLAY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DGNUNDERLAY_get", _wrap__dwg_object_entity_tio_DGNUNDERLAY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_DWFUNDERLAY_set", _wrap__dwg_object_entity_tio_DWFUNDERLAY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_DWFUNDERLAY_get", _wrap__dwg_object_entity_tio_DWFUNDERLAY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ENDREP_set", _wrap__dwg_object_entity_tio_ENDREP_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ENDREP_get", _wrap__dwg_object_entity_tio_ENDREP_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_HATCH_set", _wrap__dwg_object_entity_tio_HATCH_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_HATCH_get", _wrap__dwg_object_entity_tio_HATCH_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_IMAGE_set", _wrap__dwg_object_entity_tio_IMAGE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_IMAGE_get", _wrap__dwg_object_entity_tio_IMAGE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_JUMP_set", _wrap__dwg_object_entity_tio_JUMP_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_JUMP_get", _wrap__dwg_object_entity_tio_JUMP_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LIGHT_set", _wrap__dwg_object_entity_tio_LIGHT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LIGHT_get", _wrap__dwg_object_entity_tio_LIGHT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LWPOLYLINE_set", _wrap__dwg_object_entity_tio_LWPOLYLINE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LWPOLYLINE_get", _wrap__dwg_object_entity_tio_LWPOLYLINE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MESH_set", _wrap__dwg_object_entity_tio_MESH_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MESH_get", _wrap__dwg_object_entity_tio_MESH_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MULTILEADER_set", _wrap__dwg_object_entity_tio_MULTILEADER_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MULTILEADER_get", _wrap__dwg_object_entity_tio_MULTILEADER_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_OLE2FRAME_set", _wrap__dwg_object_entity_tio_OLE2FRAME_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_OLE2FRAME_get", _wrap__dwg_object_entity_tio_OLE2FRAME_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_PDFUNDERLAY_set", _wrap__dwg_object_entity_tio_PDFUNDERLAY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_PDFUNDERLAY_get", _wrap__dwg_object_entity_tio_PDFUNDERLAY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_REPEAT_set", _wrap__dwg_object_entity_tio_REPEAT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_REPEAT_get", _wrap__dwg_object_entity_tio_REPEAT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SECTIONOBJECT_set", _wrap__dwg_object_entity_tio_SECTIONOBJECT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SECTIONOBJECT_get", _wrap__dwg_object_entity_tio_SECTIONOBJECT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_WIPEOUT_set", _wrap__dwg_object_entity_tio_WIPEOUT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_WIPEOUT_get", _wrap__dwg_object_entity_tio_WIPEOUT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ARC_DIMENSION_set", _wrap__dwg_object_entity_tio_ARC_DIMENSION_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ARC_DIMENSION_get", _wrap__dwg_object_entity_tio_ARC_DIMENSION_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_HELIX_set", _wrap__dwg_object_entity_tio_HELIX_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_HELIX_get", _wrap__dwg_object_entity_tio_HELIX_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set", _wrap__dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_get", _wrap__dwg_object_entity_tio_LARGE_RADIAL_DIMENSION_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_set", _wrap__dwg_object_entity_tio_LAYOUTPRINTCONFIG_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LAYOUTPRINTCONFIG_get", _wrap__dwg_object_entity_tio_LAYOUTPRINTCONFIG_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_PLANESURFACE_set", _wrap__dwg_object_entity_tio_PLANESURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_PLANESURFACE_get", _wrap__dwg_object_entity_tio_PLANESURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POINTCLOUD_set", _wrap__dwg_object_entity_tio_POINTCLOUD_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POINTCLOUD_get", _wrap__dwg_object_entity_tio_POINTCLOUD_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POINTCLOUDEX_set", _wrap__dwg_object_entity_tio_POINTCLOUDEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POINTCLOUDEX_get", _wrap__dwg_object_entity_tio_POINTCLOUDEX_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_ALIGNMENTPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ARCALIGNEDTEXT_set", _wrap__dwg_object_entity_tio_ARCALIGNEDTEXT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ARCALIGNEDTEXT_get", _wrap__dwg_object_entity_tio_ARCALIGNEDTEXT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_BASEPOINTPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_EXTRUDEDSURFACE_set", _wrap__dwg_object_entity_tio_EXTRUDEDSURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_EXTRUDEDSURFACE_get", _wrap__dwg_object_entity_tio_EXTRUDEDSURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_FLIPGRIPENTITY_set", _wrap__dwg_object_entity_tio_FLIPGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_FLIPGRIPENTITY_get", _wrap__dwg_object_entity_tio_FLIPGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_FLIPPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_FLIPPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_FLIPPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_FLIPPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_GEOPOSITIONMARKER_set", _wrap__dwg_object_entity_tio_GEOPOSITIONMARKER_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_GEOPOSITIONMARKER_get", _wrap__dwg_object_entity_tio_GEOPOSITIONMARKER_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LINEARGRIPENTITY_set", _wrap__dwg_object_entity_tio_LINEARGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LINEARGRIPENTITY_get", _wrap__dwg_object_entity_tio_LINEARGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LINEARPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_LINEARPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LINEARPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_LINEARPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_LOFTEDSURFACE_set", _wrap__dwg_object_entity_tio_LOFTEDSURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_LOFTEDSURFACE_get", _wrap__dwg_object_entity_tio_LOFTEDSURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_MPOLYGON_set", _wrap__dwg_object_entity_tio_MPOLYGON_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_MPOLYGON_get", _wrap__dwg_object_entity_tio_MPOLYGON_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_NAVISWORKSMODEL_set", _wrap__dwg_object_entity_tio_NAVISWORKSMODEL_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_NAVISWORKSMODEL_get", _wrap__dwg_object_entity_tio_NAVISWORKSMODEL_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_NURBSURFACE_set", _wrap__dwg_object_entity_tio_NURBSURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_NURBSURFACE_get", _wrap__dwg_object_entity_tio_NURBSURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POINTPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_POINTPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POINTPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_POINTPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_POLARGRIPENTITY_set", _wrap__dwg_object_entity_tio_POLARGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_POLARGRIPENTITY_get", _wrap__dwg_object_entity_tio_POLARGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_REVOLVEDSURFACE_set", _wrap__dwg_object_entity_tio_REVOLVEDSURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_REVOLVEDSURFACE_get", _wrap__dwg_object_entity_tio_REVOLVEDSURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ROTATIONGRIPENTITY_set", _wrap__dwg_object_entity_tio_ROTATIONGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ROTATIONGRIPENTITY_get", _wrap__dwg_object_entity_tio_ROTATIONGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_ROTATIONPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_ROTATIONPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_ROTATIONPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_RTEXT_set", _wrap__dwg_object_entity_tio_RTEXT_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_RTEXT_get", _wrap__dwg_object_entity_tio_RTEXT_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_SWEPTSURFACE_set", _wrap__dwg_object_entity_tio_SWEPTSURFACE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_SWEPTSURFACE_get", _wrap__dwg_object_entity_tio_SWEPTSURFACE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_TABLE_set", _wrap__dwg_object_entity_tio_TABLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_TABLE_get", _wrap__dwg_object_entity_tio_TABLE_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_set", _wrap__dwg_object_entity_tio_VISIBILITYGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VISIBILITYGRIPENTITY_get", _wrap__dwg_object_entity_tio_VISIBILITYGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_VISIBILITYPARAMETERENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_XYGRIPENTITY_set", _wrap__dwg_object_entity_tio_XYGRIPENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_XYGRIPENTITY_get", _wrap__dwg_object_entity_tio_XYGRIPENTITY_get, METH_O, NULL},
	 { "_dwg_object_entity_tio_XYPARAMETERENTITY_set", _wrap__dwg_object_entity_tio_XYPARAMETERENTITY_set, METH_VARARGS, NULL},
	 { "_dwg_object_entity_tio_XYPARAMETERENTITY_get", _wrap__dwg_object_entity_tio_XYPARAMETERENTITY_get, METH_O, NULL},
	 { "new__dwg_object_entity_tio", _wrap_new__dwg_object_entity_tio, METH_NOARGS, NULL},
	 { "delete__dwg_object_entity_tio", _wrap_delete__dwg_object_entity_tio, METH_O, NULL},
	 { "_dwg_object_entity_tio_swigregister", _dwg_object_entity_tio_swigregister, METH_O, NULL},
	 { "_dwg_object_entity_tio_swiginit", _dwg_object_entity_tio_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_objid_set", _wrap_Dwg_Object_Object_objid_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_objid_get", _wrap_Dwg_Object_Object_objid_get, METH_O, NULL},
	 { "Dwg_Object_Object_tio_get", _wrap_Dwg_Object_Object_tio_get, METH_O, NULL},
	 { "Dwg_Object_Object_dwg_set", _wrap_Dwg_Object_Object_dwg_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_dwg_get", _wrap_Dwg_Object_Object_dwg_get, METH_O, NULL},
	 { "Dwg_Object_Object_num_eed_set", _wrap_Dwg_Object_Object_num_eed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_num_eed_get", _wrap_Dwg_Object_Object_num_eed_get, METH_O, NULL},
	 { "Dwg_Object_Object_eed_set", _wrap_Dwg_Object_Object_eed_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_eed_get", _wrap_Dwg_Object_Object_eed_get, METH_O, NULL},
	 { "Dwg_Object_Object_ownerhandle_set", _wrap_Dwg_Object_Object_ownerhandle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_ownerhandle_get", _wrap_Dwg_Object_Object_ownerhandle_get, METH_O, NULL},
	 { "Dwg_Object_Object_num_reactors_set", _wrap_Dwg_Object_Object_num_reactors_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_num_reactors_get", _wrap_Dwg_Object_Object_num_reactors_get, METH_O, NULL},
	 { "Dwg_Object_Object_reactors_set", _wrap_Dwg_Object_Object_reactors_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_reactors_get", _wrap_Dwg_Object_Object_reactors_get, METH_O, NULL},
	 { "Dwg_Object_Object_xdicobjhandle_set", _wrap_Dwg_Object_Object_xdicobjhandle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_xdicobjhandle_get", _wrap_Dwg_Object_Object_xdicobjhandle_get, METH_O, NULL},
	 { "Dwg_Object_Object_is_xdic_missing_set", _wrap_Dwg_Object_Object_is_xdic_missing_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_is_xdic_missing_get", _wrap_Dwg_Object_Object_is_xdic_missing_get, METH_O, NULL},
	 { "Dwg_Object_Object_has_ds_data_set", _wrap_Dwg_Object_Object_has_ds_data_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_has_ds_data_get", _wrap_Dwg_Object_Object_has_ds_data_get, METH_O, NULL},
	 { "Dwg_Object_Object_handleref_set", _wrap_Dwg_Object_Object_handleref_set, METH_VARARGS, NULL},
	 { "Dwg_Object_Object_handleref_get", _wrap_Dwg_Object_Object_handleref_get, METH_O, NULL},
	 { "new_Dwg_Object_Object", _wrap_new_Dwg_Object_Object, METH_NOARGS, NULL},
	 { "delete_Dwg_Object_Object", _wrap_delete_Dwg_Object_Object, METH_O, NULL},
	 { "Dwg_Object_Object_swigregister", Dwg_Object_Object_swigregister, METH_O, NULL},
	 { "Dwg_Object_Object_swiginit", Dwg_Object_Object_swiginit, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_APPID_set", _wrap__dwg_object_object_tio_APPID_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_APPID_get", _wrap__dwg_object_object_tio_APPID_get, METH_O, NULL},
	 { "_dwg_object_object_tio_APPID_CONTROL_set", _wrap__dwg_object_object_tio_APPID_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_APPID_CONTROL_get", _wrap__dwg_object_object_tio_APPID_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCK_CONTROL_set", _wrap__dwg_object_object_tio_BLOCK_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCK_CONTROL_get", _wrap__dwg_object_object_tio_BLOCK_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCK_HEADER_set", _wrap__dwg_object_object_tio_BLOCK_HEADER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCK_HEADER_get", _wrap__dwg_object_object_tio_BLOCK_HEADER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DICTIONARY_set", _wrap__dwg_object_object_tio_DICTIONARY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DICTIONARY_get", _wrap__dwg_object_object_tio_DICTIONARY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DIMSTYLE_set", _wrap__dwg_object_object_tio_DIMSTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DIMSTYLE_get", _wrap__dwg_object_object_tio_DIMSTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DIMSTYLE_CONTROL_set", _wrap__dwg_object_object_tio_DIMSTYLE_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DIMSTYLE_CONTROL_get", _wrap__dwg_object_object_tio_DIMSTYLE_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DUMMY_set", _wrap__dwg_object_object_tio_DUMMY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DUMMY_get", _wrap__dwg_object_object_tio_DUMMY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LAYER_set", _wrap__dwg_object_object_tio_LAYER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LAYER_get", _wrap__dwg_object_object_tio_LAYER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LAYER_CONTROL_set", _wrap__dwg_object_object_tio_LAYER_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LAYER_CONTROL_get", _wrap__dwg_object_object_tio_LAYER_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LONG_TRANSACTION_set", _wrap__dwg_object_object_tio_LONG_TRANSACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LONG_TRANSACTION_get", _wrap__dwg_object_object_tio_LONG_TRANSACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LTYPE_set", _wrap__dwg_object_object_tio_LTYPE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LTYPE_get", _wrap__dwg_object_object_tio_LTYPE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LTYPE_CONTROL_set", _wrap__dwg_object_object_tio_LTYPE_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LTYPE_CONTROL_get", _wrap__dwg_object_object_tio_LTYPE_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MLINESTYLE_set", _wrap__dwg_object_object_tio_MLINESTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MLINESTYLE_get", _wrap__dwg_object_object_tio_MLINESTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_STYLE_set", _wrap__dwg_object_object_tio_STYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_STYLE_get", _wrap__dwg_object_object_tio_STYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_STYLE_CONTROL_set", _wrap__dwg_object_object_tio_STYLE_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_STYLE_CONTROL_get", _wrap__dwg_object_object_tio_STYLE_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_UCS_set", _wrap__dwg_object_object_tio_UCS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_UCS_get", _wrap__dwg_object_object_tio_UCS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_UCS_CONTROL_set", _wrap__dwg_object_object_tio_UCS_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_UCS_CONTROL_get", _wrap__dwg_object_object_tio_UCS_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_UNKNOWN_OBJ_set", _wrap__dwg_object_object_tio_UNKNOWN_OBJ_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_UNKNOWN_OBJ_get", _wrap__dwg_object_object_tio_UNKNOWN_OBJ_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VIEW_set", _wrap__dwg_object_object_tio_VIEW_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VIEW_get", _wrap__dwg_object_object_tio_VIEW_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VIEW_CONTROL_set", _wrap__dwg_object_object_tio_VIEW_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VIEW_CONTROL_get", _wrap__dwg_object_object_tio_VIEW_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VPORT_set", _wrap__dwg_object_object_tio_VPORT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VPORT_get", _wrap__dwg_object_object_tio_VPORT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VPORT_CONTROL_set", _wrap__dwg_object_object_tio_VPORT_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VPORT_CONTROL_get", _wrap__dwg_object_object_tio_VPORT_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VX_CONTROL_set", _wrap__dwg_object_object_tio_VX_CONTROL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VX_CONTROL_get", _wrap__dwg_object_object_tio_VX_CONTROL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VX_TABLE_RECORD_set", _wrap__dwg_object_object_tio_VX_TABLE_RECORD_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VX_TABLE_RECORD_get", _wrap__dwg_object_object_tio_VX_TABLE_RECORD_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set", _wrap__dwg_object_object_tio_ACSH_BOOLEAN_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_BOOLEAN_CLASS_get", _wrap__dwg_object_object_tio_ACSH_BOOLEAN_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_BOX_CLASS_set", _wrap__dwg_object_object_tio_ACSH_BOX_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_BOX_CLASS_get", _wrap__dwg_object_object_tio_ACSH_BOX_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_CONE_CLASS_set", _wrap__dwg_object_object_tio_ACSH_CONE_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_CONE_CLASS_get", _wrap__dwg_object_object_tio_ACSH_CONE_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_set", _wrap__dwg_object_object_tio_ACSH_CYLINDER_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_CYLINDER_CLASS_get", _wrap__dwg_object_object_tio_ACSH_CYLINDER_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_FILLET_CLASS_set", _wrap__dwg_object_object_tio_ACSH_FILLET_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_FILLET_CLASS_get", _wrap__dwg_object_object_tio_ACSH_FILLET_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_HISTORY_CLASS_set", _wrap__dwg_object_object_tio_ACSH_HISTORY_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_HISTORY_CLASS_get", _wrap__dwg_object_object_tio_ACSH_HISTORY_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_SPHERE_CLASS_set", _wrap__dwg_object_object_tio_ACSH_SPHERE_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_SPHERE_CLASS_get", _wrap__dwg_object_object_tio_ACSH_SPHERE_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_TORUS_CLASS_set", _wrap__dwg_object_object_tio_ACSH_TORUS_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_TORUS_CLASS_get", _wrap__dwg_object_object_tio_ACSH_TORUS_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_WEDGE_CLASS_set", _wrap__dwg_object_object_tio_ACSH_WEDGE_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_WEDGE_CLASS_get", _wrap__dwg_object_object_tio_ACSH_WEDGE_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set", _wrap__dwg_object_object_tio_ASSOCGEOMDEPENDENCY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCGEOMDEPENDENCY_get", _wrap__dwg_object_object_tio_ASSOCGEOMDEPENDENCY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCNETWORK_set", _wrap__dwg_object_object_tio_ASSOCNETWORK_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCNETWORK_get", _wrap__dwg_object_object_tio_ASSOCNETWORK_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_set", _wrap__dwg_object_object_tio_BLOCKALIGNMENTGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNMENTGRIP_get", _wrap__dwg_object_object_tio_BLOCKALIGNMENTGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKALIGNMENTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKBASEPOINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPACTION_set", _wrap__dwg_object_object_tio_BLOCKFLIPACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPACTION_get", _wrap__dwg_object_object_tio_BLOCKFLIPACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPGRIP_set", _wrap__dwg_object_object_tio_BLOCKFLIPGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPGRIP_get", _wrap__dwg_object_object_tio_BLOCKFLIPGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKFLIPPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKFLIPPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKFLIPPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set", _wrap__dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_get", _wrap__dwg_object_object_tio_BLOCKGRIPLOCATIONCOMPONENT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARGRIP_set", _wrap__dwg_object_object_tio_BLOCKLINEARGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARGRIP_get", _wrap__dwg_object_object_tio_BLOCKLINEARGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPGRIP_set", _wrap__dwg_object_object_tio_BLOCKLOOKUPGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPGRIP_get", _wrap__dwg_object_object_tio_BLOCKLOOKUPGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKMOVEACTION_set", _wrap__dwg_object_object_tio_BLOCKMOVEACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKMOVEACTION_get", _wrap__dwg_object_object_tio_BLOCKMOVEACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATEACTION_set", _wrap__dwg_object_object_tio_BLOCKROTATEACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATEACTION_get", _wrap__dwg_object_object_tio_BLOCKROTATEACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATIONGRIP_set", _wrap__dwg_object_object_tio_BLOCKROTATIONGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATIONGRIP_get", _wrap__dwg_object_object_tio_BLOCKROTATIONGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKSCALEACTION_set", _wrap__dwg_object_object_tio_BLOCKSCALEACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKSCALEACTION_get", _wrap__dwg_object_object_tio_BLOCKSCALEACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_set", _wrap__dwg_object_object_tio_BLOCKVISIBILITYGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKVISIBILITYGRIP_get", _wrap__dwg_object_object_tio_BLOCKVISIBILITYGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_CELLSTYLEMAP_set", _wrap__dwg_object_object_tio_CELLSTYLEMAP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_CELLSTYLEMAP_get", _wrap__dwg_object_object_tio_CELLSTYLEMAP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DETAILVIEWSTYLE_set", _wrap__dwg_object_object_tio_DETAILVIEWSTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DETAILVIEWSTYLE_get", _wrap__dwg_object_object_tio_DETAILVIEWSTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DICTIONARYVAR_set", _wrap__dwg_object_object_tio_DICTIONARYVAR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DICTIONARYVAR_get", _wrap__dwg_object_object_tio_DICTIONARYVAR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DICTIONARYWDFLT_set", _wrap__dwg_object_object_tio_DICTIONARYWDFLT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DICTIONARYWDFLT_get", _wrap__dwg_object_object_tio_DICTIONARYWDFLT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set", _wrap__dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_get", _wrap__dwg_object_object_tio_DYNAMICBLOCKPURGEPREVENTER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_FIELD_set", _wrap__dwg_object_object_tio_FIELD_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_FIELD_get", _wrap__dwg_object_object_tio_FIELD_get, METH_O, NULL},
	 { "_dwg_object_object_tio_FIELDLIST_set", _wrap__dwg_object_object_tio_FIELDLIST_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_FIELDLIST_get", _wrap__dwg_object_object_tio_FIELDLIST_get, METH_O, NULL},
	 { "_dwg_object_object_tio_GEODATA_set", _wrap__dwg_object_object_tio_GEODATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_GEODATA_get", _wrap__dwg_object_object_tio_GEODATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_GROUP_set", _wrap__dwg_object_object_tio_GROUP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_GROUP_get", _wrap__dwg_object_object_tio_GROUP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_IDBUFFER_set", _wrap__dwg_object_object_tio_IDBUFFER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_IDBUFFER_get", _wrap__dwg_object_object_tio_IDBUFFER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_IMAGEDEF_set", _wrap__dwg_object_object_tio_IMAGEDEF_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_IMAGEDEF_get", _wrap__dwg_object_object_tio_IMAGEDEF_get, METH_O, NULL},
	 { "_dwg_object_object_tio_IMAGEDEF_REACTOR_set", _wrap__dwg_object_object_tio_IMAGEDEF_REACTOR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_IMAGEDEF_REACTOR_get", _wrap__dwg_object_object_tio_IMAGEDEF_REACTOR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_INDEX_set", _wrap__dwg_object_object_tio_INDEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_INDEX_get", _wrap__dwg_object_object_tio_INDEX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LAYERFILTER_set", _wrap__dwg_object_object_tio_LAYERFILTER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LAYERFILTER_get", _wrap__dwg_object_object_tio_LAYERFILTER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LAYER_INDEX_set", _wrap__dwg_object_object_tio_LAYER_INDEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LAYER_INDEX_get", _wrap__dwg_object_object_tio_LAYER_INDEX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LAYOUT_set", _wrap__dwg_object_object_tio_LAYOUT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LAYOUT_get", _wrap__dwg_object_object_tio_LAYOUT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PLACEHOLDER_set", _wrap__dwg_object_object_tio_PLACEHOLDER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PLACEHOLDER_get", _wrap__dwg_object_object_tio_PLACEHOLDER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PLOTSETTINGS_set", _wrap__dwg_object_object_tio_PLOTSETTINGS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PLOTSETTINGS_get", _wrap__dwg_object_object_tio_PLOTSETTINGS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RASTERVARIABLES_set", _wrap__dwg_object_object_tio_RASTERVARIABLES_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RASTERVARIABLES_get", _wrap__dwg_object_object_tio_RASTERVARIABLES_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RENDERENVIRONMENT_set", _wrap__dwg_object_object_tio_RENDERENVIRONMENT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RENDERENVIRONMENT_get", _wrap__dwg_object_object_tio_RENDERENVIRONMENT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SCALE_set", _wrap__dwg_object_object_tio_SCALE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SCALE_get", _wrap__dwg_object_object_tio_SCALE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SECTIONVIEWSTYLE_set", _wrap__dwg_object_object_tio_SECTIONVIEWSTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SECTIONVIEWSTYLE_get", _wrap__dwg_object_object_tio_SECTIONVIEWSTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SECTION_MANAGER_set", _wrap__dwg_object_object_tio_SECTION_MANAGER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SECTION_MANAGER_get", _wrap__dwg_object_object_tio_SECTION_MANAGER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SORTENTSTABLE_set", _wrap__dwg_object_object_tio_SORTENTSTABLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SORTENTSTABLE_get", _wrap__dwg_object_object_tio_SORTENTSTABLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SPATIAL_FILTER_set", _wrap__dwg_object_object_tio_SPATIAL_FILTER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SPATIAL_FILTER_get", _wrap__dwg_object_object_tio_SPATIAL_FILTER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SUN_set", _wrap__dwg_object_object_tio_SUN_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SUN_get", _wrap__dwg_object_object_tio_SUN_get, METH_O, NULL},
	 { "_dwg_object_object_tio_TABLEGEOMETRY_set", _wrap__dwg_object_object_tio_TABLEGEOMETRY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_TABLEGEOMETRY_get", _wrap__dwg_object_object_tio_TABLEGEOMETRY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VBA_PROJECT_set", _wrap__dwg_object_object_tio_VBA_PROJECT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VBA_PROJECT_get", _wrap__dwg_object_object_tio_VBA_PROJECT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_VISUALSTYLE_set", _wrap__dwg_object_object_tio_VISUALSTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_VISUALSTYLE_get", _wrap__dwg_object_object_tio_VISUALSTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_WIPEOUTVARIABLES_set", _wrap__dwg_object_object_tio_WIPEOUTVARIABLES_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_WIPEOUTVARIABLES_get", _wrap__dwg_object_object_tio_WIPEOUTVARIABLES_get, METH_O, NULL},
	 { "_dwg_object_object_tio_XRECORD_set", _wrap__dwg_object_object_tio_XRECORD_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_XRECORD_get", _wrap__dwg_object_object_tio_XRECORD_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PDFDEFINITION_set", _wrap__dwg_object_object_tio_PDFDEFINITION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PDFDEFINITION_get", _wrap__dwg_object_object_tio_PDFDEFINITION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DGNDEFINITION_set", _wrap__dwg_object_object_tio_DGNDEFINITION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DGNDEFINITION_get", _wrap__dwg_object_object_tio_DGNDEFINITION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DWFDEFINITION_set", _wrap__dwg_object_object_tio_DWFDEFINITION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DWFDEFINITION_get", _wrap__dwg_object_object_tio_DWFDEFINITION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_BREP_CLASS_set", _wrap__dwg_object_object_tio_ACSH_BREP_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_BREP_CLASS_get", _wrap__dwg_object_object_tio_ACSH_BREP_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_set", _wrap__dwg_object_object_tio_ACSH_CHAMFER_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_CHAMFER_CLASS_get", _wrap__dwg_object_object_tio_ACSH_CHAMFER_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_set", _wrap__dwg_object_object_tio_ACSH_PYRAMID_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_PYRAMID_CLASS_get", _wrap__dwg_object_object_tio_ACSH_PYRAMID_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_ALDIMOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set", _wrap__dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_get", _wrap__dwg_object_object_tio_ASSOC2DCONSTRAINTGROUP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCACTION_set", _wrap__dwg_object_object_tio_ASSOCACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCACTION_get", _wrap__dwg_object_object_tio_ASSOCACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCARRAYACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCARRAYACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCASMBODYACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCBLENDSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCCOMPOUNDACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCDEPENDENCY_set", _wrap__dwg_object_object_tio_ASSOCDEPENDENCY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCDEPENDENCY_get", _wrap__dwg_object_object_tio_ASSOCDEPENDENCY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set", _wrap__dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_get", _wrap__dwg_object_object_tio_ASSOCDIMDEPENDENCYBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCEXTENDSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCEXTRUDEDSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCFACEACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCFACEACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCFACEACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCFILLETSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCLOFTEDSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCNETWORKSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCOBJECTACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCOFFSETSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCOSNAPPOINTREFACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCPATCHSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCPATHACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCPATHACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCPATHACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCPLANESURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCPOINTREFACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCREVOLVEDSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCTRIMSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set", _wrap__dwg_object_object_tio_ASSOCVALUEDEPENDENCY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCVALUEDEPENDENCY_get", _wrap__dwg_object_object_tio_ASSOCVALUEDEPENDENCY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCVARIABLE_set", _wrap__dwg_object_object_tio_ASSOCVARIABLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCVARIABLE_get", _wrap__dwg_object_object_tio_ASSOCVARIABLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCVERTEXACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_BLKREFOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKALIGNEDCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKANGULARCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKARRAYACTION_set", _wrap__dwg_object_object_tio_BLOCKARRAYACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKARRAYACTION_get", _wrap__dwg_object_object_tio_BLOCKARRAYACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKDIAMETRICCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKHORIZONTALCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKLINEARCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKLINEARPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLINEARPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKLINEARPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPACTION_set", _wrap__dwg_object_object_tio_BLOCKLOOKUPACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPACTION_get", _wrap__dwg_object_object_tio_BLOCKLOOKUPACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKLOOKUPPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKLOOKUPPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKLOOKUPPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set", _wrap__dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_get", _wrap__dwg_object_object_tio_BLOCKPARAMDEPENDENCYBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPOINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKPOINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPOINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKPOINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARGRIP_set", _wrap__dwg_object_object_tio_BLOCKPOLARGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARGRIP_get", _wrap__dwg_object_object_tio_BLOCKPOLARGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKPOLARPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKPOLARPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set", _wrap__dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_get", _wrap__dwg_object_object_tio_BLOCKPOLARSTRETCHACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKRADIALCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKREPRESENTATION_set", _wrap__dwg_object_object_tio_BLOCKREPRESENTATION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKREPRESENTATION_get", _wrap__dwg_object_object_tio_BLOCKREPRESENTATION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKROTATIONPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKROTATIONPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKROTATIONPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKSTRETCHACTION_set", _wrap__dwg_object_object_tio_BLOCKSTRETCHACTION_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKSTRETCHACTION_get", _wrap__dwg_object_object_tio_BLOCKSTRETCHACTION_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKUSERPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKUSERPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKUSERPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKUSERPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKVERTICALCONSTRAINTPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKVISIBILITYPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKXYGRIP_set", _wrap__dwg_object_object_tio_BLOCKXYGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKXYGRIP_get", _wrap__dwg_object_object_tio_BLOCKXYGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKXYPARAMETER_set", _wrap__dwg_object_object_tio_BLOCKXYPARAMETER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKXYPARAMETER_get", _wrap__dwg_object_object_tio_BLOCKXYPARAMETER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DATALINK_set", _wrap__dwg_object_object_tio_DATALINK_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DATALINK_get", _wrap__dwg_object_object_tio_DATALINK_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DBCOLOR_set", _wrap__dwg_object_object_tio_DBCOLOR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DBCOLOR_get", _wrap__dwg_object_object_tio_DBCOLOR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_EVALUATION_GRAPH_set", _wrap__dwg_object_object_tio_EVALUATION_GRAPH_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_EVALUATION_GRAPH_get", _wrap__dwg_object_object_tio_EVALUATION_GRAPH_get, METH_O, NULL},
	 { "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_FCFOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_FCFOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_FCFOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_GRADIENT_BACKGROUND_set", _wrap__dwg_object_object_tio_GRADIENT_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_GRADIENT_BACKGROUND_get", _wrap__dwg_object_object_tio_GRADIENT_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set", _wrap__dwg_object_object_tio_GROUND_PLANE_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_GROUND_PLANE_BACKGROUND_get", _wrap__dwg_object_object_tio_GROUND_PLANE_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_IBL_BACKGROUND_set", _wrap__dwg_object_object_tio_IBL_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_IBL_BACKGROUND_get", _wrap__dwg_object_object_tio_IBL_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_IMAGE_BACKGROUND_set", _wrap__dwg_object_object_tio_IMAGE_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_IMAGE_BACKGROUND_get", _wrap__dwg_object_object_tio_IMAGE_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_LEADEROBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_LIGHTLIST_set", _wrap__dwg_object_object_tio_LIGHTLIST_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_LIGHTLIST_get", _wrap__dwg_object_object_tio_LIGHTLIST_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MATERIAL_set", _wrap__dwg_object_object_tio_MATERIAL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MATERIAL_get", _wrap__dwg_object_object_tio_MATERIAL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set", _wrap__dwg_object_object_tio_MENTALRAYRENDERSETTINGS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MENTALRAYRENDERSETTINGS_get", _wrap__dwg_object_object_tio_MENTALRAYRENDERSETTINGS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MLEADERSTYLE_set", _wrap__dwg_object_object_tio_MLEADERSTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MLEADERSTYLE_get", _wrap__dwg_object_object_tio_MLEADERSTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_MTEXTOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_OBJECT_PTR_set", _wrap__dwg_object_object_tio_OBJECT_PTR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_OBJECT_PTR_get", _wrap__dwg_object_object_tio_OBJECT_PTR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set", _wrap__dwg_object_object_tio_PARTIAL_VIEWING_INDEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PARTIAL_VIEWING_INDEX_get", _wrap__dwg_object_object_tio_PARTIAL_VIEWING_INDEX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDCOLORMAP_set", _wrap__dwg_object_object_tio_POINTCLOUDCOLORMAP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDCOLORMAP_get", _wrap__dwg_object_object_tio_POINTCLOUDCOLORMAP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_set", _wrap__dwg_object_object_tio_POINTCLOUDDEF_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_get", _wrap__dwg_object_object_tio_POINTCLOUDDEF_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEFEX_set", _wrap__dwg_object_object_tio_POINTCLOUDDEFEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEFEX_get", _wrap__dwg_object_object_tio_POINTCLOUDDEFEX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set", _wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_get", _wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set", _wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_get", _wrap__dwg_object_object_tio_POINTCLOUDDEF_REACTOR_EX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PROXY_OBJECT_set", _wrap__dwg_object_object_tio_PROXY_OBJECT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PROXY_OBJECT_get", _wrap__dwg_object_object_tio_PROXY_OBJECT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set", _wrap__dwg_object_object_tio_RAPIDRTRENDERSETTINGS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RAPIDRTRENDERSETTINGS_get", _wrap__dwg_object_object_tio_RAPIDRTRENDERSETTINGS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RENDERENTRY_set", _wrap__dwg_object_object_tio_RENDERENTRY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RENDERENTRY_get", _wrap__dwg_object_object_tio_RENDERENTRY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RENDERGLOBAL_set", _wrap__dwg_object_object_tio_RENDERGLOBAL_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RENDERGLOBAL_get", _wrap__dwg_object_object_tio_RENDERGLOBAL_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RENDERSETTINGS_set", _wrap__dwg_object_object_tio_RENDERSETTINGS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RENDERSETTINGS_get", _wrap__dwg_object_object_tio_RENDERSETTINGS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SECTION_SETTINGS_set", _wrap__dwg_object_object_tio_SECTION_SETTINGS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SECTION_SETTINGS_get", _wrap__dwg_object_object_tio_SECTION_SETTINGS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_set", _wrap__dwg_object_object_tio_SKYLIGHT_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SKYLIGHT_BACKGROUND_get", _wrap__dwg_object_object_tio_SKYLIGHT_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SOLID_BACKGROUND_set", _wrap__dwg_object_object_tio_SOLID_BACKGROUND_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SOLID_BACKGROUND_get", _wrap__dwg_object_object_tio_SOLID_BACKGROUND_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SPATIAL_INDEX_set", _wrap__dwg_object_object_tio_SPATIAL_INDEX_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SPATIAL_INDEX_get", _wrap__dwg_object_object_tio_SPATIAL_INDEX_get, METH_O, NULL},
	 { "_dwg_object_object_tio_TABLESTYLE_set", _wrap__dwg_object_object_tio_TABLESTYLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_TABLESTYLE_get", _wrap__dwg_object_object_tio_TABLESTYLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_TEXTOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set", _wrap__dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_get", _wrap__dwg_object_object_tio_ASSOCARRAYMODIFYPARAMETERS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set", _wrap__dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_get", _wrap__dwg_object_object_tio_ASSOCARRAYPATHPARAMETERS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set", _wrap__dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_get", _wrap__dwg_object_object_tio_ASSOCARRAYPOLARPARAMETERS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set", _wrap__dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_get", _wrap__dwg_object_object_tio_ASSOCARRAYRECTANGULARPARAMETERS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACMECOMMANDHISTORY_set", _wrap__dwg_object_object_tio_ACMECOMMANDHISTORY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACMECOMMANDHISTORY_get", _wrap__dwg_object_object_tio_ACMECOMMANDHISTORY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACMESCOPE_set", _wrap__dwg_object_object_tio_ACMESCOPE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACMESCOPE_get", _wrap__dwg_object_object_tio_ACMESCOPE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACMESTATEMGR_set", _wrap__dwg_object_object_tio_ACMESTATEMGR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACMESTATEMGR_get", _wrap__dwg_object_object_tio_ACMESTATEMGR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set", _wrap__dwg_object_object_tio_ACSH_EXTRUSION_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_EXTRUSION_CLASS_get", _wrap__dwg_object_object_tio_ACSH_EXTRUSION_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_LOFT_CLASS_set", _wrap__dwg_object_object_tio_ACSH_LOFT_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_LOFT_CLASS_get", _wrap__dwg_object_object_tio_ACSH_LOFT_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_set", _wrap__dwg_object_object_tio_ACSH_REVOLVE_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_REVOLVE_CLASS_get", _wrap__dwg_object_object_tio_ACSH_REVOLVE_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ACSH_SWEEP_CLASS_set", _wrap__dwg_object_object_tio_ACSH_SWEEP_CLASS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ACSH_SWEEP_CLASS_get", _wrap__dwg_object_object_tio_ACSH_SWEEP_CLASS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_ANGDIMOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_ANNOTSCALEOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOC3POINTANGULARDIMACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCALIGNEDDIMACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCARRAYMODIFYACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set", _wrap__dwg_object_object_tio_ASSOCEDGEACTIONPARAM_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGEACTIONPARAM_get", _wrap__dwg_object_object_tio_ASSOCEDGEACTIONPARAM_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCEDGECHAMFERACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCEDGEFILLETACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCMLEADERACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCMLEADERACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCMLEADERACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCORDINATEDIMACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set", _wrap__dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_get", _wrap__dwg_object_object_tio_ASSOCPERSSUBENTMANAGER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCRESTOREENTITYSTATEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCROTATEDDIMACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set", _wrap__dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_get", _wrap__dwg_object_object_tio_ASSOCSWEPTSURFACEACTIONBODY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_set", _wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPROPERTIESTABLE_get", _wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set", _wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_get", _wrap__dwg_object_object_tio_BLOCKPROPERTIESTABLEGRIP_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BREAKDATA_set", _wrap__dwg_object_object_tio_BREAKDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BREAKDATA_get", _wrap__dwg_object_object_tio_BREAKDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_BREAKPOINTREF_set", _wrap__dwg_object_object_tio_BREAKPOINTREF_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_BREAKPOINTREF_get", _wrap__dwg_object_object_tio_BREAKPOINTREF_get, METH_O, NULL},
	 { "_dwg_object_object_tio_CONTEXTDATAMANAGER_set", _wrap__dwg_object_object_tio_CONTEXTDATAMANAGER_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_CONTEXTDATAMANAGER_get", _wrap__dwg_object_object_tio_CONTEXTDATAMANAGER_get, METH_O, NULL},
	 { "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_set", _wrap__dwg_object_object_tio_CSACDOCUMENTOPTIONS_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_CSACDOCUMENTOPTIONS_get", _wrap__dwg_object_object_tio_CSACDOCUMENTOPTIONS_get, METH_O, NULL},
	 { "_dwg_object_object_tio_CURVEPATH_set", _wrap__dwg_object_object_tio_CURVEPATH_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_CURVEPATH_get", _wrap__dwg_object_object_tio_CURVEPATH_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DATATABLE_set", _wrap__dwg_object_object_tio_DATATABLE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DATATABLE_get", _wrap__dwg_object_object_tio_DATATABLE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DIMASSOC_set", _wrap__dwg_object_object_tio_DIMASSOC_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DIMASSOC_get", _wrap__dwg_object_object_tio_DIMASSOC_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_DMDIMOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set", _wrap__dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_get", _wrap__dwg_object_object_tio_DYNAMICBLOCKPROXYNODE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_GEOMAPIMAGE_set", _wrap__dwg_object_object_tio_GEOMAPIMAGE_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_GEOMAPIMAGE_get", _wrap__dwg_object_object_tio_GEOMAPIMAGE_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_MLEADEROBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MOTIONPATH_set", _wrap__dwg_object_object_tio_MOTIONPATH_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MOTIONPATH_get", _wrap__dwg_object_object_tio_MOTIONPATH_get, METH_O, NULL},
	 { "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_MTEXTATTRIBUTEOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_NAVISWORKSMODELDEF_set", _wrap__dwg_object_object_tio_NAVISWORKSMODELDEF_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_NAVISWORKSMODELDEF_get", _wrap__dwg_object_object_tio_NAVISWORKSMODELDEF_get, METH_O, NULL},
	 { "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_ORDDIMOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_PERSUBENTMGR_set", _wrap__dwg_object_object_tio_PERSUBENTMGR_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_PERSUBENTMGR_get", _wrap__dwg_object_object_tio_PERSUBENTMGR_get, METH_O, NULL},
	 { "_dwg_object_object_tio_POINTPATH_set", _wrap__dwg_object_object_tio_POINTPATH_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_POINTPATH_get", _wrap__dwg_object_object_tio_POINTPATH_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_RADIMLGOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set", _wrap__dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_get", _wrap__dwg_object_object_tio_RADIMOBJECTCONTEXTDATA_get, METH_O, NULL},
	 { "_dwg_object_object_tio_SUNSTUDY_set", _wrap__dwg_object_object_tio_SUNSTUDY_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_SUNSTUDY_get", _wrap__dwg_object_object_tio_SUNSTUDY_get, METH_O, NULL},
	 { "_dwg_object_object_tio_TABLECONTENT_set", _wrap__dwg_object_object_tio_TABLECONTENT_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_TABLECONTENT_get", _wrap__dwg_object_object_tio_TABLECONTENT_get, METH_O, NULL},
	 { "_dwg_object_object_tio_TVDEVICEPROPERTIES_set", _wrap__dwg_object_object_tio_TVDEVICEPROPERTIES_set, METH_VARARGS, NULL},
	 { "_dwg_object_object_tio_TVDEVICEPROPERTIES_get", _wrap__dwg_object_object_tio_TVDEVICEPROPERTIES_get, METH_O, NULL},
	 { "new__dwg_object_object_tio", _wrap_new__dwg_object_object_tio, METH_NOARGS, NULL},
	 { "delete__dwg_object_object_tio", _wrap_delete__dwg_object_object_tio, METH_O, NULL},
	 { "_dwg_object_object_tio_swigregister", _dwg_object_object_tio_swigregister, METH_O, NULL},
	 { "_dwg_object_object_tio_swiginit", _dwg_object_object_tio_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Class_number_set", _wrap_Dwg_Class_number_set, METH_VARARGS, NULL},
	 { "Dwg_Class_number_get", _wrap_Dwg_Class_number_get, METH_O, NULL},
	 { "Dwg_Class_proxyflag_set", _wrap_Dwg_Class_proxyflag_set, METH_VARARGS, NULL},
	 { "Dwg_Class_proxyflag_get", _wrap_Dwg_Class_proxyflag_get, METH_O, NULL},
	 { "Dwg_Class_appname_set", _wrap_Dwg_Class_appname_set, METH_VARARGS, NULL},
	 { "Dwg_Class_appname_get", _wrap_Dwg_Class_appname_get, METH_O, NULL},
	 { "Dwg_Class_cppname_set", _wrap_Dwg_Class_cppname_set, METH_VARARGS, NULL},
	 { "Dwg_Class_cppname_get", _wrap_Dwg_Class_cppname_get, METH_O, NULL},
	 { "Dwg_Class_dxfname_set", _wrap_Dwg_Class_dxfname_set, METH_VARARGS, NULL},
	 { "Dwg_Class_dxfname_get", _wrap_Dwg_Class_dxfname_get, METH_O, NULL},
	 { "Dwg_Class_dxfname_u_set", _wrap_Dwg_Class_dxfname_u_set, METH_VARARGS, NULL},
	 { "Dwg_Class_dxfname_u_get", _wrap_Dwg_Class_dxfname_u_get, METH_O, NULL},
	 { "Dwg_Class_is_zombie_set", _wrap_Dwg_Class_is_zombie_set, METH_VARARGS, NULL},
	 { "Dwg_Class_is_zombie_get", _wrap_Dwg_Class_is_zombie_get, METH_O, NULL},
	 { "Dwg_Class_item_class_id_set", _wrap_Dwg_Class_item_class_id_set, METH_VARARGS, NULL},
	 { "Dwg_Class_item_class_id_get", _wrap_Dwg_Class_item_class_id_get, METH_O, NULL},
	 { "Dwg_Class_num_instances_set", _wrap_Dwg_Class_num_instances_set, METH_VARARGS, NULL},
	 { "Dwg_Class_num_instances_get", _wrap_Dwg_Class_num_instances_get, METH_O, NULL},
	 { "Dwg_Class_dwg_version_set", _wrap_Dwg_Class_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Class_dwg_version_get", _wrap_Dwg_Class_dwg_version_get, METH_O, NULL},
	 { "Dwg_Class_maint_version_set", _wrap_Dwg_Class_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Class_maint_version_get", _wrap_Dwg_Class_maint_version_get, METH_O, NULL},
	 { "Dwg_Class_unknown_1_set", _wrap_Dwg_Class_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_Class_unknown_1_get", _wrap_Dwg_Class_unknown_1_get, METH_O, NULL},
	 { "Dwg_Class_unknown_2_set", _wrap_Dwg_Class_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_Class_unknown_2_get", _wrap_Dwg_Class_unknown_2_get, METH_O, NULL},
	 { "new_Dwg_Class", _wrap_new_Dwg_Class, METH_NOARGS, NULL},
	 { "delete_Dwg_Class", _wrap_delete_Dwg_Class, METH_O, NULL},
	 { "Dwg_Class_swigregister", Dwg_Class_swigregister, METH_O, NULL},
	 { "Dwg_Class_swiginit", Dwg_Class_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Object_size_set", _wrap_Dwg_Object_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_size_get", _wrap_Dwg_Object_size_get, METH_O, NULL},
	 { "Dwg_Object_address_set", _wrap_Dwg_Object_address_set, METH_VARARGS, NULL},
	 { "Dwg_Object_address_get", _wrap_Dwg_Object_address_get, METH_O, NULL},
	 { "Dwg_Object_type_set", _wrap_Dwg_Object_type_set, METH_VARARGS, NULL},
	 { "Dwg_Object_type_get", _wrap_Dwg_Object_type_get, METH_O, NULL},
	 { "Dwg_Object_index_set", _wrap_Dwg_Object_index_set, METH_VARARGS, NULL},
	 { "Dwg_Object_index_get", _wrap_Dwg_Object_index_get, METH_O, NULL},
	 { "Dwg_Object_fixedtype_set", _wrap_Dwg_Object_fixedtype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_fixedtype_get", _wrap_Dwg_Object_fixedtype_get, METH_O, NULL},
	 { "Dwg_Object_name_set", _wrap_Dwg_Object_name_set, METH_VARARGS, NULL},
	 { "Dwg_Object_name_get", _wrap_Dwg_Object_name_get, METH_O, NULL},
	 { "Dwg_Object_dxfname_set", _wrap_Dwg_Object_dxfname_set, METH_VARARGS, NULL},
	 { "Dwg_Object_dxfname_get", _wrap_Dwg_Object_dxfname_get, METH_O, NULL},
	 { "Dwg_Object_supertype_set", _wrap_Dwg_Object_supertype_set, METH_VARARGS, NULL},
	 { "Dwg_Object_supertype_get", _wrap_Dwg_Object_supertype_get, METH_O, NULL},
	 { "Dwg_Object_tio_get", _wrap_Dwg_Object_tio_get, METH_O, NULL},
	 { "Dwg_Object_handle_set", _wrap_Dwg_Object_handle_set, METH_VARARGS, NULL},
	 { "Dwg_Object_handle_get", _wrap_Dwg_Object_handle_get, METH_O, NULL},
	 { "Dwg_Object_parent_set", _wrap_Dwg_Object_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Object_parent_get", _wrap_Dwg_Object_parent_get, METH_O, NULL},
	 { "Dwg_Object_klass_set", _wrap_Dwg_Object_klass_set, METH_VARARGS, NULL},
	 { "Dwg_Object_klass_get", _wrap_Dwg_Object_klass_get, METH_O, NULL},
	 { "Dwg_Object_bitsize_set", _wrap_Dwg_Object_bitsize_set, METH_VARARGS, NULL},
	 { "Dwg_Object_bitsize_get", _wrap_Dwg_Object_bitsize_get, METH_O, NULL},
	 { "Dwg_Object_bitsize_pos_set", _wrap_Dwg_Object_bitsize_pos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_bitsize_pos_get", _wrap_Dwg_Object_bitsize_pos_get, METH_O, NULL},
	 { "Dwg_Object_hdlpos_set", _wrap_Dwg_Object_hdlpos_set, METH_VARARGS, NULL},
	 { "Dwg_Object_hdlpos_get", _wrap_Dwg_Object_hdlpos_get, METH_O, NULL},
	 { "Dwg_Object_was_bitsize_set_set", _wrap_Dwg_Object_was_bitsize_set_set, METH_VARARGS, NULL},
	 { "Dwg_Object_was_bitsize_set_get", _wrap_Dwg_Object_was_bitsize_set_get, METH_O, NULL},
	 { "Dwg_Object_has_strings_set", _wrap_Dwg_Object_has_strings_set, METH_VARARGS, NULL},
	 { "Dwg_Object_has_strings_get", _wrap_Dwg_Object_has_strings_get, METH_O, NULL},
	 { "Dwg_Object_stringstream_size_set", _wrap_Dwg_Object_stringstream_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_stringstream_size_get", _wrap_Dwg_Object_stringstream_size_get, METH_O, NULL},
	 { "Dwg_Object_handlestream_size_set", _wrap_Dwg_Object_handlestream_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_handlestream_size_get", _wrap_Dwg_Object_handlestream_size_get, METH_O, NULL},
	 { "Dwg_Object_common_size_set", _wrap_Dwg_Object_common_size_set, METH_VARARGS, NULL},
	 { "Dwg_Object_common_size_get", _wrap_Dwg_Object_common_size_get, METH_O, NULL},
	 { "Dwg_Object_num_unknown_bits_set", _wrap_Dwg_Object_num_unknown_bits_set, METH_VARARGS, NULL},
	 { "Dwg_Object_num_unknown_bits_get", _wrap_Dwg_Object_num_unknown_bits_get, METH_O, NULL},
	 { "Dwg_Object_unknown_bits_set", _wrap_Dwg_Object_unknown_bits_set, METH_VARARGS, NULL},
	 { "Dwg_Object_unknown_bits_get", _wrap_Dwg_Object_unknown_bits_get, METH_O, NULL},
	 { "Dwg_Object_num_unknown_rest_set", _wrap_Dwg_Object_num_unknown_rest_set, METH_VARARGS, NULL},
	 { "Dwg_Object_num_unknown_rest_get", _wrap_Dwg_Object_num_unknown_rest_get, METH_O, NULL},
	 { "Dwg_Object_unknown_rest_set", _wrap_Dwg_Object_unknown_rest_set, METH_VARARGS, NULL},
	 { "Dwg_Object_unknown_rest_get", _wrap_Dwg_Object_unknown_rest_get, METH_O, NULL},
	 { "new_Dwg_Object", _wrap_new_Dwg_Object, METH_NOARGS, NULL},
	 { "delete_Dwg_Object", _wrap_delete_Dwg_Object, METH_O, NULL},
	 { "Dwg_Object_swigregister", Dwg_Object_swigregister, METH_O, NULL},
	 { "Dwg_Object_swiginit", Dwg_Object_swiginit, METH_VARARGS, NULL},
	 { "_dwg_object_tio_entity_set", _wrap__dwg_object_tio_entity_set, METH_VARARGS, NULL},
	 { "_dwg_object_tio_entity_get", _wrap__dwg_object_tio_entity_get, METH_O, NULL},
	 { "_dwg_object_tio_object_set", _wrap__dwg_object_tio_object_set, METH_VARARGS, NULL},
	 { "_dwg_object_tio_object_get", _wrap__dwg_object_tio_object_get, METH_O, NULL},
	 { "new__dwg_object_tio", _wrap_new__dwg_object_tio, METH_NOARGS, NULL},
	 { "delete__dwg_object_tio", _wrap_delete__dwg_object_tio, METH_O, NULL},
	 { "_dwg_object_tio_swigregister", _dwg_object_tio_swigregister, METH_O, NULL},
	 { "_dwg_object_tio_swiginit", _dwg_object_tio_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Chain_chain_set", _wrap_Dwg_Chain_chain_set, METH_VARARGS, NULL},
	 { "Dwg_Chain_chain_get", _wrap_Dwg_Chain_chain_get, METH_O, NULL},
	 { "Dwg_Chain_size_set", _wrap_Dwg_Chain_size_set, METH_VARARGS, NULL},
	 { "Dwg_Chain_size_get", _wrap_Dwg_Chain_size_get, METH_O, NULL},
	 { "Dwg_Chain_byte_set", _wrap_Dwg_Chain_byte_set, METH_VARARGS, NULL},
	 { "Dwg_Chain_byte_get", _wrap_Dwg_Chain_byte_get, METH_O, NULL},
	 { "Dwg_Chain_bit_set", _wrap_Dwg_Chain_bit_set, METH_VARARGS, NULL},
	 { "Dwg_Chain_bit_get", _wrap_Dwg_Chain_bit_get, METH_O, NULL},
	 { "new_Dwg_Chain", _wrap_new_Dwg_Chain, METH_NOARGS, NULL},
	 { "delete_Dwg_Chain", _wrap_delete_Dwg_Chain, METH_O, NULL},
	 { "Dwg_Chain_swigregister", Dwg_Chain_swigregister, METH_O, NULL},
	 { "Dwg_Chain_swiginit", Dwg_Chain_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Section_number_set", _wrap_Dwg_Section_number_set, METH_VARARGS, NULL},
	 { "Dwg_Section_number_get", _wrap_Dwg_Section_number_get, METH_O, NULL},
	 { "Dwg_Section_size_set", _wrap_Dwg_Section_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_size_get", _wrap_Dwg_Section_size_get, METH_O, NULL},
	 { "Dwg_Section_address_set", _wrap_Dwg_Section_address_set, METH_VARARGS, NULL},
	 { "Dwg_Section_address_get", _wrap_Dwg_Section_address_get, METH_O, NULL},
	 { "Dwg_Section_objid_r11_set", _wrap_Dwg_Section_objid_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Section_objid_r11_get", _wrap_Dwg_Section_objid_r11_get, METH_O, NULL},
	 { "Dwg_Section_parent_set", _wrap_Dwg_Section_parent_set, METH_VARARGS, NULL},
	 { "Dwg_Section_parent_get", _wrap_Dwg_Section_parent_get, METH_O, NULL},
	 { "Dwg_Section_left_set", _wrap_Dwg_Section_left_set, METH_VARARGS, NULL},
	 { "Dwg_Section_left_get", _wrap_Dwg_Section_left_get, METH_O, NULL},
	 { "Dwg_Section_right_set", _wrap_Dwg_Section_right_set, METH_VARARGS, NULL},
	 { "Dwg_Section_right_get", _wrap_Dwg_Section_right_get, METH_O, NULL},
	 { "Dwg_Section_x00_set", _wrap_Dwg_Section_x00_set, METH_VARARGS, NULL},
	 { "Dwg_Section_x00_get", _wrap_Dwg_Section_x00_get, METH_O, NULL},
	 { "Dwg_Section_type_set", _wrap_Dwg_Section_type_set, METH_VARARGS, NULL},
	 { "Dwg_Section_type_get", _wrap_Dwg_Section_type_get, METH_O, NULL},
	 { "Dwg_Section_name_set", _wrap_Dwg_Section_name_set, METH_VARARGS, NULL},
	 { "Dwg_Section_name_get", _wrap_Dwg_Section_name_get, METH_O, NULL},
	 { "Dwg_Section_section_type_set", _wrap_Dwg_Section_section_type_set, METH_VARARGS, NULL},
	 { "Dwg_Section_section_type_get", _wrap_Dwg_Section_section_type_get, METH_O, NULL},
	 { "Dwg_Section_decomp_data_size_set", _wrap_Dwg_Section_decomp_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_decomp_data_size_get", _wrap_Dwg_Section_decomp_data_size_get, METH_O, NULL},
	 { "Dwg_Section_comp_data_size_set", _wrap_Dwg_Section_comp_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_comp_data_size_get", _wrap_Dwg_Section_comp_data_size_get, METH_O, NULL},
	 { "Dwg_Section_compression_type_set", _wrap_Dwg_Section_compression_type_set, METH_VARARGS, NULL},
	 { "Dwg_Section_compression_type_get", _wrap_Dwg_Section_compression_type_get, METH_O, NULL},
	 { "Dwg_Section_checksum_set", _wrap_Dwg_Section_checksum_set, METH_VARARGS, NULL},
	 { "Dwg_Section_checksum_get", _wrap_Dwg_Section_checksum_get, METH_O, NULL},
	 { "Dwg_Section_flags_r11_set", _wrap_Dwg_Section_flags_r11_set, METH_VARARGS, NULL},
	 { "Dwg_Section_flags_r11_get", _wrap_Dwg_Section_flags_r11_get, METH_O, NULL},
	 { "new_Dwg_Section", _wrap_new_Dwg_Section, METH_NOARGS, NULL},
	 { "delete_Dwg_Section", _wrap_delete_Dwg_Section, METH_O, NULL},
	 { "Dwg_Section_swigregister", Dwg_Section_swigregister, METH_O, NULL},
	 { "Dwg_Section_swiginit", Dwg_Section_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_num_desc_set", _wrap_Dwg_Section_InfoHdr_num_desc_set, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_num_desc_get", _wrap_Dwg_Section_InfoHdr_num_desc_get, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_compressed_set", _wrap_Dwg_Section_InfoHdr_compressed_set, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_compressed_get", _wrap_Dwg_Section_InfoHdr_compressed_get, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_max_size_set", _wrap_Dwg_Section_InfoHdr_max_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_max_size_get", _wrap_Dwg_Section_InfoHdr_max_size_get, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_encrypted_set", _wrap_Dwg_Section_InfoHdr_encrypted_set, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_encrypted_get", _wrap_Dwg_Section_InfoHdr_encrypted_get, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_num_desc2_set", _wrap_Dwg_Section_InfoHdr_num_desc2_set, METH_VARARGS, NULL},
	 { "Dwg_Section_InfoHdr_num_desc2_get", _wrap_Dwg_Section_InfoHdr_num_desc2_get, METH_O, NULL},
	 { "new_Dwg_Section_InfoHdr", _wrap_new_Dwg_Section_InfoHdr, METH_NOARGS, NULL},
	 { "delete_Dwg_Section_InfoHdr", _wrap_delete_Dwg_Section_InfoHdr, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_swigregister", Dwg_Section_InfoHdr_swigregister, METH_O, NULL},
	 { "Dwg_Section_InfoHdr_swiginit", Dwg_Section_InfoHdr_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_size_set", _wrap_Dwg_Section_Info_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_size_get", _wrap_Dwg_Section_Info_size_get, METH_O, NULL},
	 { "Dwg_Section_Info_num_sections_set", _wrap_Dwg_Section_Info_num_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_num_sections_get", _wrap_Dwg_Section_Info_num_sections_get, METH_O, NULL},
	 { "Dwg_Section_Info_max_decomp_size_set", _wrap_Dwg_Section_Info_max_decomp_size_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_max_decomp_size_get", _wrap_Dwg_Section_Info_max_decomp_size_get, METH_O, NULL},
	 { "Dwg_Section_Info_unknown_set", _wrap_Dwg_Section_Info_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_unknown_get", _wrap_Dwg_Section_Info_unknown_get, METH_O, NULL},
	 { "Dwg_Section_Info_compressed_set", _wrap_Dwg_Section_Info_compressed_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_compressed_get", _wrap_Dwg_Section_Info_compressed_get, METH_O, NULL},
	 { "Dwg_Section_Info_type_set", _wrap_Dwg_Section_Info_type_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_type_get", _wrap_Dwg_Section_Info_type_get, METH_O, NULL},
	 { "Dwg_Section_Info_encrypted_set", _wrap_Dwg_Section_Info_encrypted_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_encrypted_get", _wrap_Dwg_Section_Info_encrypted_get, METH_O, NULL},
	 { "Dwg_Section_Info_name_set", _wrap_Dwg_Section_Info_name_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_name_get", _wrap_Dwg_Section_Info_name_get, METH_O, NULL},
	 { "Dwg_Section_Info_fixedtype_set", _wrap_Dwg_Section_Info_fixedtype_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_fixedtype_get", _wrap_Dwg_Section_Info_fixedtype_get, METH_O, NULL},
	 { "Dwg_Section_Info_sections_set", _wrap_Dwg_Section_Info_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Section_Info_sections_get", _wrap_Dwg_Section_Info_sections_get, METH_O, NULL},
	 { "new_Dwg_Section_Info", _wrap_new_Dwg_Section_Info, METH_NOARGS, NULL},
	 { "delete_Dwg_Section_Info", _wrap_delete_Dwg_Section_Info, METH_O, NULL},
	 { "Dwg_Section_Info_swigregister", Dwg_Section_Info_swigregister, METH_O, NULL},
	 { "Dwg_Section_Info_swiginit", Dwg_Section_Info_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_Property_tag_set", _wrap_Dwg_SummaryInfo_Property_tag_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_Property_tag_get", _wrap_Dwg_SummaryInfo_Property_tag_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_Property_value_set", _wrap_Dwg_SummaryInfo_Property_value_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_Property_value_get", _wrap_Dwg_SummaryInfo_Property_value_get, METH_O, NULL},
	 { "new_Dwg_SummaryInfo_Property", _wrap_new_Dwg_SummaryInfo_Property, METH_NOARGS, NULL},
	 { "delete_Dwg_SummaryInfo_Property", _wrap_delete_Dwg_SummaryInfo_Property, METH_O, NULL},
	 { "Dwg_SummaryInfo_Property_swigregister", Dwg_SummaryInfo_Property_swigregister, METH_O, NULL},
	 { "Dwg_SummaryInfo_Property_swiginit", Dwg_SummaryInfo_Property_swiginit, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_filename_set", _wrap_Dwg_FileDepList_Files_filename_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_filename_get", _wrap_Dwg_FileDepList_Files_filename_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_filepath_set", _wrap_Dwg_FileDepList_Files_filepath_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_filepath_get", _wrap_Dwg_FileDepList_Files_filepath_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_fingerprint_set", _wrap_Dwg_FileDepList_Files_fingerprint_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_fingerprint_get", _wrap_Dwg_FileDepList_Files_fingerprint_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_version_set", _wrap_Dwg_FileDepList_Files_version_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_version_get", _wrap_Dwg_FileDepList_Files_version_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_feature_index_set", _wrap_Dwg_FileDepList_Files_feature_index_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_feature_index_get", _wrap_Dwg_FileDepList_Files_feature_index_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_timestamp_set", _wrap_Dwg_FileDepList_Files_timestamp_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_timestamp_get", _wrap_Dwg_FileDepList_Files_timestamp_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_filesize_set", _wrap_Dwg_FileDepList_Files_filesize_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_filesize_get", _wrap_Dwg_FileDepList_Files_filesize_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_affects_graphics_set", _wrap_Dwg_FileDepList_Files_affects_graphics_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_affects_graphics_get", _wrap_Dwg_FileDepList_Files_affects_graphics_get, METH_O, NULL},
	 { "Dwg_FileDepList_Files_refcount_set", _wrap_Dwg_FileDepList_Files_refcount_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_Files_refcount_get", _wrap_Dwg_FileDepList_Files_refcount_get, METH_O, NULL},
	 { "new_Dwg_FileDepList_Files", _wrap_new_Dwg_FileDepList_Files, METH_NOARGS, NULL},
	 { "delete_Dwg_FileDepList_Files", _wrap_delete_Dwg_FileDepList_Files, METH_O, NULL},
	 { "Dwg_FileDepList_Files_swigregister", Dwg_FileDepList_Files_swigregister, METH_O, NULL},
	 { "Dwg_FileDepList_Files_swiginit", Dwg_FileDepList_Files_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SegmentIndex_offset_set", _wrap_Dwg_AcDs_SegmentIndex_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SegmentIndex_offset_get", _wrap_Dwg_AcDs_SegmentIndex_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_SegmentIndex_size_set", _wrap_Dwg_AcDs_SegmentIndex_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SegmentIndex_size_get", _wrap_Dwg_AcDs_SegmentIndex_size_get, METH_O, NULL},
	 { "new_Dwg_AcDs_SegmentIndex", _wrap_new_Dwg_AcDs_SegmentIndex, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_SegmentIndex", _wrap_delete_Dwg_AcDs_SegmentIndex, METH_O, NULL},
	 { "Dwg_AcDs_SegmentIndex_swigregister", Dwg_AcDs_SegmentIndex_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_SegmentIndex_swiginit", Dwg_AcDs_SegmentIndex_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_segidx_set", _wrap_Dwg_AcDs_DataIndex_Entry_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_segidx_get", _wrap_Dwg_AcDs_DataIndex_Entry_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_offset_set", _wrap_Dwg_AcDs_DataIndex_Entry_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_offset_get", _wrap_Dwg_AcDs_DataIndex_Entry_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_schidx_set", _wrap_Dwg_AcDs_DataIndex_Entry_schidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_schidx_get", _wrap_Dwg_AcDs_DataIndex_Entry_schidx_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataIndex_Entry", _wrap_new_Dwg_AcDs_DataIndex_Entry, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataIndex_Entry", _wrap_delete_Dwg_AcDs_DataIndex_Entry, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_swigregister", Dwg_AcDs_DataIndex_Entry_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_Entry_swiginit", Dwg_AcDs_DataIndex_Entry_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_num_entries_set", _wrap_Dwg_AcDs_DataIndex_num_entries_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_num_entries_get", _wrap_Dwg_AcDs_DataIndex_num_entries_get, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_di_unknown_set", _wrap_Dwg_AcDs_DataIndex_di_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_di_unknown_get", _wrap_Dwg_AcDs_DataIndex_di_unknown_get, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_entries_set", _wrap_Dwg_AcDs_DataIndex_entries_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataIndex_entries_get", _wrap_Dwg_AcDs_DataIndex_entries_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataIndex", _wrap_new_Dwg_AcDs_DataIndex, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataIndex", _wrap_delete_Dwg_AcDs_DataIndex, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_swigregister", Dwg_AcDs_DataIndex_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataIndex_swiginit", Dwg_AcDs_DataIndex_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_entry_size_set", _wrap_Dwg_AcDs_Data_RecordHdr_entry_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_entry_size_get", _wrap_Dwg_AcDs_Data_RecordHdr_entry_size_get, METH_O, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_unknown_set", _wrap_Dwg_AcDs_Data_RecordHdr_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_unknown_get", _wrap_Dwg_AcDs_Data_RecordHdr_unknown_get, METH_O, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_handle_set", _wrap_Dwg_AcDs_Data_RecordHdr_handle_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_handle_get", _wrap_Dwg_AcDs_Data_RecordHdr_handle_get, METH_O, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_offset_set", _wrap_Dwg_AcDs_Data_RecordHdr_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_offset_get", _wrap_Dwg_AcDs_Data_RecordHdr_offset_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Data_RecordHdr", _wrap_new_Dwg_AcDs_Data_RecordHdr, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Data_RecordHdr", _wrap_delete_Dwg_AcDs_Data_RecordHdr, METH_O, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_swigregister", Dwg_AcDs_Data_RecordHdr_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Data_RecordHdr_swiginit", Dwg_AcDs_Data_RecordHdr_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_Record_data_size_set", _wrap_Dwg_AcDs_Data_Record_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_Record_data_size_get", _wrap_Dwg_AcDs_Data_Record_data_size_get, METH_O, NULL},
	 { "Dwg_AcDs_Data_Record_blob_set", _wrap_Dwg_AcDs_Data_Record_blob_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_Record_blob_get", _wrap_Dwg_AcDs_Data_Record_blob_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Data_Record", _wrap_new_Dwg_AcDs_Data_Record, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Data_Record", _wrap_delete_Dwg_AcDs_Data_Record, METH_O, NULL},
	 { "Dwg_AcDs_Data_Record_swigregister", Dwg_AcDs_Data_Record_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Data_Record_swiginit", Dwg_AcDs_Data_Record_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_record_hdrs_set", _wrap_Dwg_AcDs_Data_record_hdrs_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_record_hdrs_get", _wrap_Dwg_AcDs_Data_record_hdrs_get, METH_O, NULL},
	 { "Dwg_AcDs_Data_records_set", _wrap_Dwg_AcDs_Data_records_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Data_records_get", _wrap_Dwg_AcDs_Data_records_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Data", _wrap_new_Dwg_AcDs_Data, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Data", _wrap_delete_Dwg_AcDs_Data, METH_O, NULL},
	 { "Dwg_AcDs_Data_swigregister", Dwg_AcDs_Data_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Data_swiginit", Dwg_AcDs_Data_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_segidx_set", _wrap_Dwg_AcDs_DataBlobRef_Page_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_segidx_get", _wrap_Dwg_AcDs_DataBlobRef_Page_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_size_set", _wrap_Dwg_AcDs_DataBlobRef_Page_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_size_get", _wrap_Dwg_AcDs_DataBlobRef_Page_size_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataBlobRef_Page", _wrap_new_Dwg_AcDs_DataBlobRef_Page, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataBlobRef_Page", _wrap_delete_Dwg_AcDs_DataBlobRef_Page, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_swigregister", Dwg_AcDs_DataBlobRef_Page_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_Page_swiginit", Dwg_AcDs_DataBlobRef_Page_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_total_data_size_set", _wrap_Dwg_AcDs_DataBlobRef_total_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_total_data_size_get", _wrap_Dwg_AcDs_DataBlobRef_total_data_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_num_pages_set", _wrap_Dwg_AcDs_DataBlobRef_num_pages_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_num_pages_get", _wrap_Dwg_AcDs_DataBlobRef_num_pages_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_record_size_set", _wrap_Dwg_AcDs_DataBlobRef_record_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_record_size_get", _wrap_Dwg_AcDs_DataBlobRef_record_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_page_size_set", _wrap_Dwg_AcDs_DataBlobRef_page_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_page_size_get", _wrap_Dwg_AcDs_DataBlobRef_page_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_unknown_1_set", _wrap_Dwg_AcDs_DataBlobRef_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_unknown_1_get", _wrap_Dwg_AcDs_DataBlobRef_unknown_1_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_unknown_2_set", _wrap_Dwg_AcDs_DataBlobRef_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_unknown_2_get", _wrap_Dwg_AcDs_DataBlobRef_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_pages_set", _wrap_Dwg_AcDs_DataBlobRef_pages_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlobRef_pages_get", _wrap_Dwg_AcDs_DataBlobRef_pages_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataBlobRef", _wrap_new_Dwg_AcDs_DataBlobRef, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataBlobRef", _wrap_delete_Dwg_AcDs_DataBlobRef, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_swigregister", Dwg_AcDs_DataBlobRef_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataBlobRef_swiginit", Dwg_AcDs_DataBlobRef_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_data_size_set", _wrap_Dwg_AcDs_DataBlob_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_data_size_get", _wrap_Dwg_AcDs_DataBlob_data_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_page_count_set", _wrap_Dwg_AcDs_DataBlob_page_count_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_page_count_get", _wrap_Dwg_AcDs_DataBlob_page_count_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_record_size_set", _wrap_Dwg_AcDs_DataBlob_record_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_record_size_get", _wrap_Dwg_AcDs_DataBlob_record_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_page_size_set", _wrap_Dwg_AcDs_DataBlob_page_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_page_size_get", _wrap_Dwg_AcDs_DataBlob_page_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_unknown_1_set", _wrap_Dwg_AcDs_DataBlob_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_unknown_1_get", _wrap_Dwg_AcDs_DataBlob_unknown_1_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_unknown_2_set", _wrap_Dwg_AcDs_DataBlob_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_unknown_2_get", _wrap_Dwg_AcDs_DataBlob_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_ref_set", _wrap_Dwg_AcDs_DataBlob_ref_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob_ref_get", _wrap_Dwg_AcDs_DataBlob_ref_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataBlob", _wrap_new_Dwg_AcDs_DataBlob, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataBlob", _wrap_delete_Dwg_AcDs_DataBlob, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_swigregister", Dwg_AcDs_DataBlob_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob_swiginit", Dwg_AcDs_DataBlob_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_total_data_size_set", _wrap_Dwg_AcDs_DataBlob01_total_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_total_data_size_get", _wrap_Dwg_AcDs_DataBlob01_total_data_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_page_start_offset_set", _wrap_Dwg_AcDs_DataBlob01_page_start_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_page_start_offset_get", _wrap_Dwg_AcDs_DataBlob01_page_start_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_page_index_set", _wrap_Dwg_AcDs_DataBlob01_page_index_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_page_index_get", _wrap_Dwg_AcDs_DataBlob01_page_index_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_page_count_set", _wrap_Dwg_AcDs_DataBlob01_page_count_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_page_count_get", _wrap_Dwg_AcDs_DataBlob01_page_count_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_page_data_size_set", _wrap_Dwg_AcDs_DataBlob01_page_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_page_data_size_get", _wrap_Dwg_AcDs_DataBlob01_page_data_size_get, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_page_data_set", _wrap_Dwg_AcDs_DataBlob01_page_data_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_DataBlob01_page_data_get", _wrap_Dwg_AcDs_DataBlob01_page_data_get, METH_O, NULL},
	 { "new_Dwg_AcDs_DataBlob01", _wrap_new_Dwg_AcDs_DataBlob01, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_DataBlob01", _wrap_delete_Dwg_AcDs_DataBlob01, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_swigregister", Dwg_AcDs_DataBlob01_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_DataBlob01_swiginit", Dwg_AcDs_DataBlob01_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_index_set", _wrap_Dwg_AcDs_SchemaIndex_Prop_index_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_index_get", _wrap_Dwg_AcDs_SchemaIndex_Prop_index_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_segidx_set", _wrap_Dwg_AcDs_SchemaIndex_Prop_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_segidx_get", _wrap_Dwg_AcDs_SchemaIndex_Prop_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_offset_set", _wrap_Dwg_AcDs_SchemaIndex_Prop_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_offset_get", _wrap_Dwg_AcDs_SchemaIndex_Prop_offset_get, METH_O, NULL},
	 { "new_Dwg_AcDs_SchemaIndex_Prop", _wrap_new_Dwg_AcDs_SchemaIndex_Prop, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_SchemaIndex_Prop", _wrap_delete_Dwg_AcDs_SchemaIndex_Prop, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_swigregister", Dwg_AcDs_SchemaIndex_Prop_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_Prop_swiginit", Dwg_AcDs_SchemaIndex_Prop_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_num_props_set", _wrap_Dwg_AcDs_SchemaIndex_num_props_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_num_props_get", _wrap_Dwg_AcDs_SchemaIndex_num_props_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_unknown_1_set", _wrap_Dwg_AcDs_SchemaIndex_si_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_unknown_1_get", _wrap_Dwg_AcDs_SchemaIndex_si_unknown_1_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_props_set", _wrap_Dwg_AcDs_SchemaIndex_props_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_props_get", _wrap_Dwg_AcDs_SchemaIndex_props_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_tag_set", _wrap_Dwg_AcDs_SchemaIndex_si_tag_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_tag_get", _wrap_Dwg_AcDs_SchemaIndex_si_tag_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_num_prop_entries_set", _wrap_Dwg_AcDs_SchemaIndex_num_prop_entries_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_num_prop_entries_get", _wrap_Dwg_AcDs_SchemaIndex_num_prop_entries_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_unknown_2_set", _wrap_Dwg_AcDs_SchemaIndex_si_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_si_unknown_2_get", _wrap_Dwg_AcDs_SchemaIndex_si_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_prop_entries_set", _wrap_Dwg_AcDs_SchemaIndex_prop_entries_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaIndex_prop_entries_get", _wrap_Dwg_AcDs_SchemaIndex_prop_entries_get, METH_O, NULL},
	 { "new_Dwg_AcDs_SchemaIndex", _wrap_new_Dwg_AcDs_SchemaIndex, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_SchemaIndex", _wrap_delete_Dwg_AcDs_SchemaIndex, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_swigregister", Dwg_AcDs_SchemaIndex_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_SchemaIndex_swiginit", Dwg_AcDs_SchemaIndex_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_flags_set", _wrap_Dwg_AcDs_Schema_Prop_flags_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_flags_get", _wrap_Dwg_AcDs_Schema_Prop_flags_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_namidx_set", _wrap_Dwg_AcDs_Schema_Prop_namidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_namidx_get", _wrap_Dwg_AcDs_Schema_Prop_namidx_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_type_set", _wrap_Dwg_AcDs_Schema_Prop_type_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_type_get", _wrap_Dwg_AcDs_Schema_Prop_type_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_type_size_set", _wrap_Dwg_AcDs_Schema_Prop_type_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_type_size_get", _wrap_Dwg_AcDs_Schema_Prop_type_size_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_unknown_1_set", _wrap_Dwg_AcDs_Schema_Prop_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_unknown_1_get", _wrap_Dwg_AcDs_Schema_Prop_unknown_1_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_unknown_2_set", _wrap_Dwg_AcDs_Schema_Prop_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_unknown_2_get", _wrap_Dwg_AcDs_Schema_Prop_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_num_values_set", _wrap_Dwg_AcDs_Schema_Prop_num_values_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_num_values_get", _wrap_Dwg_AcDs_Schema_Prop_num_values_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_values_set", _wrap_Dwg_AcDs_Schema_Prop_values_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_Prop_values_get", _wrap_Dwg_AcDs_Schema_Prop_values_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Schema_Prop", _wrap_new_Dwg_AcDs_Schema_Prop, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Schema_Prop", _wrap_delete_Dwg_AcDs_Schema_Prop, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_swigregister", Dwg_AcDs_Schema_Prop_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Schema_Prop_swiginit", Dwg_AcDs_Schema_Prop_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_num_index_set", _wrap_Dwg_AcDs_Schema_num_index_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_num_index_get", _wrap_Dwg_AcDs_Schema_num_index_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_index_set", _wrap_Dwg_AcDs_Schema_index_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_index_get", _wrap_Dwg_AcDs_Schema_index_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_num_props_set", _wrap_Dwg_AcDs_Schema_num_props_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_num_props_get", _wrap_Dwg_AcDs_Schema_num_props_get, METH_O, NULL},
	 { "Dwg_AcDs_Schema_props_set", _wrap_Dwg_AcDs_Schema_props_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Schema_props_get", _wrap_Dwg_AcDs_Schema_props_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Schema", _wrap_new_Dwg_AcDs_Schema, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Schema", _wrap_delete_Dwg_AcDs_Schema, METH_O, NULL},
	 { "Dwg_AcDs_Schema_swigregister", Dwg_AcDs_Schema_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Schema_swiginit", Dwg_AcDs_Schema_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_size_set", _wrap_Dwg_AcDs_SchemaData_UProp_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_size_get", _wrap_Dwg_AcDs_SchemaData_UProp_size_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_flags_set", _wrap_Dwg_AcDs_SchemaData_UProp_flags_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_flags_get", _wrap_Dwg_AcDs_SchemaData_UProp_flags_get, METH_O, NULL},
	 { "new_Dwg_AcDs_SchemaData_UProp", _wrap_new_Dwg_AcDs_SchemaData_UProp, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_SchemaData_UProp", _wrap_delete_Dwg_AcDs_SchemaData_UProp, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_swigregister", Dwg_AcDs_SchemaData_UProp_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_UProp_swiginit", Dwg_AcDs_SchemaData_UProp_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_num_uprops_set", _wrap_Dwg_AcDs_SchemaData_num_uprops_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_num_uprops_get", _wrap_Dwg_AcDs_SchemaData_num_uprops_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_uprops_set", _wrap_Dwg_AcDs_SchemaData_uprops_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_uprops_get", _wrap_Dwg_AcDs_SchemaData_uprops_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_num_schemas_set", _wrap_Dwg_AcDs_SchemaData_num_schemas_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_num_schemas_get", _wrap_Dwg_AcDs_SchemaData_num_schemas_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_schemas_set", _wrap_Dwg_AcDs_SchemaData_schemas_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_schemas_get", _wrap_Dwg_AcDs_SchemaData_schemas_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_num_propnames_set", _wrap_Dwg_AcDs_SchemaData_num_propnames_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_num_propnames_get", _wrap_Dwg_AcDs_SchemaData_num_propnames_get, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_propnames_set", _wrap_Dwg_AcDs_SchemaData_propnames_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_SchemaData_propnames_get", _wrap_Dwg_AcDs_SchemaData_propnames_get, METH_O, NULL},
	 { "new_Dwg_AcDs_SchemaData", _wrap_new_Dwg_AcDs_SchemaData, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_SchemaData", _wrap_delete_Dwg_AcDs_SchemaData, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_swigregister", Dwg_AcDs_SchemaData_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_SchemaData_swiginit", Dwg_AcDs_SchemaData_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdx_handle_set", _wrap_Dwg_AcDs_Search_IdIdx_handle_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdx_handle_get", _wrap_Dwg_AcDs_Search_IdIdx_handle_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdx_num_ididx_set", _wrap_Dwg_AcDs_Search_IdIdx_num_ididx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdx_num_ididx_get", _wrap_Dwg_AcDs_Search_IdIdx_num_ididx_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdx_ididx_set", _wrap_Dwg_AcDs_Search_IdIdx_ididx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdx_ididx_get", _wrap_Dwg_AcDs_Search_IdIdx_ididx_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Search_IdIdx", _wrap_new_Dwg_AcDs_Search_IdIdx, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Search_IdIdx", _wrap_delete_Dwg_AcDs_Search_IdIdx, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdx_swigregister", Dwg_AcDs_Search_IdIdx_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdx_swiginit", Dwg_AcDs_Search_IdIdx_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_num_ididx_set", _wrap_Dwg_AcDs_Search_IdIdxs_num_ididx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_num_ididx_get", _wrap_Dwg_AcDs_Search_IdIdxs_num_ididx_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_ididx_set", _wrap_Dwg_AcDs_Search_IdIdxs_ididx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_ididx_get", _wrap_Dwg_AcDs_Search_IdIdxs_ididx_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Search_IdIdxs", _wrap_new_Dwg_AcDs_Search_IdIdxs, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Search_IdIdxs", _wrap_delete_Dwg_AcDs_Search_IdIdxs, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_swigregister", Dwg_AcDs_Search_IdIdxs_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Search_IdIdxs_swiginit", Dwg_AcDs_Search_IdIdxs_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_schema_namidx_set", _wrap_Dwg_AcDs_Search_Data_schema_namidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_schema_namidx_get", _wrap_Dwg_AcDs_Search_Data_schema_namidx_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_num_sortedidx_set", _wrap_Dwg_AcDs_Search_Data_num_sortedidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_num_sortedidx_get", _wrap_Dwg_AcDs_Search_Data_num_sortedidx_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_sortedidx_set", _wrap_Dwg_AcDs_Search_Data_sortedidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_sortedidx_get", _wrap_Dwg_AcDs_Search_Data_sortedidx_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_num_ididxs_set", _wrap_Dwg_AcDs_Search_Data_num_ididxs_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_num_ididxs_get", _wrap_Dwg_AcDs_Search_Data_num_ididxs_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_unknown_set", _wrap_Dwg_AcDs_Search_Data_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_unknown_get", _wrap_Dwg_AcDs_Search_Data_unknown_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_ididxs_set", _wrap_Dwg_AcDs_Search_Data_ididxs_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_Data_ididxs_get", _wrap_Dwg_AcDs_Search_Data_ididxs_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Search_Data", _wrap_new_Dwg_AcDs_Search_Data, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Search_Data", _wrap_delete_Dwg_AcDs_Search_Data, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_swigregister", Dwg_AcDs_Search_Data_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Search_Data_swiginit", Dwg_AcDs_Search_Data_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_num_search_set", _wrap_Dwg_AcDs_Search_num_search_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_num_search_get", _wrap_Dwg_AcDs_Search_num_search_get, METH_O, NULL},
	 { "Dwg_AcDs_Search_search_set", _wrap_Dwg_AcDs_Search_search_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Search_search_get", _wrap_Dwg_AcDs_Search_search_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Search", _wrap_new_Dwg_AcDs_Search, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Search", _wrap_delete_Dwg_AcDs_Search, METH_O, NULL},
	 { "Dwg_AcDs_Search_swigregister", Dwg_AcDs_Search_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Search_swiginit", Dwg_AcDs_Search_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_signature_set", _wrap_Dwg_AcDs_Segment_signature_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_signature_get", _wrap_Dwg_AcDs_Segment_signature_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_name_set", _wrap_Dwg_AcDs_Segment_name_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_name_get", _wrap_Dwg_AcDs_Segment_name_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_type_set", _wrap_Dwg_AcDs_Segment_type_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_type_get", _wrap_Dwg_AcDs_Segment_type_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_segment_idx_set", _wrap_Dwg_AcDs_Segment_segment_idx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_segment_idx_get", _wrap_Dwg_AcDs_Segment_segment_idx_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_is_blob01_set", _wrap_Dwg_AcDs_Segment_is_blob01_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_is_blob01_get", _wrap_Dwg_AcDs_Segment_is_blob01_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_segsize_set", _wrap_Dwg_AcDs_Segment_segsize_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_segsize_get", _wrap_Dwg_AcDs_Segment_segsize_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_unknown_2_set", _wrap_Dwg_AcDs_Segment_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_unknown_2_get", _wrap_Dwg_AcDs_Segment_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_ds_version_set", _wrap_Dwg_AcDs_Segment_ds_version_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_ds_version_get", _wrap_Dwg_AcDs_Segment_ds_version_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_unknown_3_set", _wrap_Dwg_AcDs_Segment_unknown_3_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_unknown_3_get", _wrap_Dwg_AcDs_Segment_unknown_3_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_data_algn_offset_set", _wrap_Dwg_AcDs_Segment_data_algn_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_data_algn_offset_get", _wrap_Dwg_AcDs_Segment_data_algn_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_objdata_algn_offset_set", _wrap_Dwg_AcDs_Segment_objdata_algn_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_objdata_algn_offset_get", _wrap_Dwg_AcDs_Segment_objdata_algn_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_Segment_padding_set", _wrap_Dwg_AcDs_Segment_padding_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_Segment_padding_get", _wrap_Dwg_AcDs_Segment_padding_get, METH_O, NULL},
	 { "new_Dwg_AcDs_Segment", _wrap_new_Dwg_AcDs_Segment, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs_Segment", _wrap_delete_Dwg_AcDs_Segment, METH_O, NULL},
	 { "Dwg_AcDs_Segment_swigregister", Dwg_AcDs_Segment_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_Segment_swiginit", Dwg_AcDs_Segment_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AcDs_file_signature_set", _wrap_Dwg_AcDs_file_signature_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_file_signature_get", _wrap_Dwg_AcDs_file_signature_get, METH_O, NULL},
	 { "Dwg_AcDs_file_header_size_set", _wrap_Dwg_AcDs_file_header_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_file_header_size_get", _wrap_Dwg_AcDs_file_header_size_get, METH_O, NULL},
	 { "Dwg_AcDs_unknown_1_set", _wrap_Dwg_AcDs_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_unknown_1_get", _wrap_Dwg_AcDs_unknown_1_get, METH_O, NULL},
	 { "Dwg_AcDs_version_set", _wrap_Dwg_AcDs_version_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_version_get", _wrap_Dwg_AcDs_version_get, METH_O, NULL},
	 { "Dwg_AcDs_unknown_2_set", _wrap_Dwg_AcDs_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_unknown_2_get", _wrap_Dwg_AcDs_unknown_2_get, METH_O, NULL},
	 { "Dwg_AcDs_ds_version_set", _wrap_Dwg_AcDs_ds_version_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_ds_version_get", _wrap_Dwg_AcDs_ds_version_get, METH_O, NULL},
	 { "Dwg_AcDs_segidx_offset_set", _wrap_Dwg_AcDs_segidx_offset_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_segidx_offset_get", _wrap_Dwg_AcDs_segidx_offset_get, METH_O, NULL},
	 { "Dwg_AcDs_segidx_unknown_set", _wrap_Dwg_AcDs_segidx_unknown_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_segidx_unknown_get", _wrap_Dwg_AcDs_segidx_unknown_get, METH_O, NULL},
	 { "Dwg_AcDs_num_segidx_set", _wrap_Dwg_AcDs_num_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_num_segidx_get", _wrap_Dwg_AcDs_num_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_schidx_segidx_set", _wrap_Dwg_AcDs_schidx_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_schidx_segidx_get", _wrap_Dwg_AcDs_schidx_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_datidx_segidx_set", _wrap_Dwg_AcDs_datidx_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_datidx_segidx_get", _wrap_Dwg_AcDs_datidx_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_search_segidx_set", _wrap_Dwg_AcDs_search_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_search_segidx_get", _wrap_Dwg_AcDs_search_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_prvsav_segidx_set", _wrap_Dwg_AcDs_prvsav_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_prvsav_segidx_get", _wrap_Dwg_AcDs_prvsav_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_file_size_set", _wrap_Dwg_AcDs_file_size_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_file_size_get", _wrap_Dwg_AcDs_file_size_get, METH_O, NULL},
	 { "Dwg_AcDs_total_segments_set", _wrap_Dwg_AcDs_total_segments_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_total_segments_get", _wrap_Dwg_AcDs_total_segments_get, METH_O, NULL},
	 { "Dwg_AcDs_segidx_set", _wrap_Dwg_AcDs_segidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_segidx_get", _wrap_Dwg_AcDs_segidx_get, METH_O, NULL},
	 { "Dwg_AcDs_datidx_set", _wrap_Dwg_AcDs_datidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_datidx_get", _wrap_Dwg_AcDs_datidx_get, METH_O, NULL},
	 { "Dwg_AcDs_data_set", _wrap_Dwg_AcDs_data_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_data_get", _wrap_Dwg_AcDs_data_get, METH_O, NULL},
	 { "Dwg_AcDs_blob01_set", _wrap_Dwg_AcDs_blob01_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_blob01_get", _wrap_Dwg_AcDs_blob01_get, METH_O, NULL},
	 { "Dwg_AcDs_schidx_set", _wrap_Dwg_AcDs_schidx_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_schidx_get", _wrap_Dwg_AcDs_schidx_get, METH_O, NULL},
	 { "Dwg_AcDs_schdat_set", _wrap_Dwg_AcDs_schdat_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_schdat_get", _wrap_Dwg_AcDs_schdat_get, METH_O, NULL},
	 { "Dwg_AcDs_search_set", _wrap_Dwg_AcDs_search_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_search_get", _wrap_Dwg_AcDs_search_get, METH_O, NULL},
	 { "Dwg_AcDs_segments_set", _wrap_Dwg_AcDs_segments_set, METH_VARARGS, NULL},
	 { "Dwg_AcDs_segments_get", _wrap_Dwg_AcDs_segments_get, METH_O, NULL},
	 { "new_Dwg_AcDs", _wrap_new_Dwg_AcDs, METH_NOARGS, NULL},
	 { "delete_Dwg_AcDs", _wrap_delete_Dwg_AcDs, METH_O, NULL},
	 { "Dwg_AcDs_swigregister", Dwg_AcDs_swigregister, METH_O, NULL},
	 { "Dwg_AcDs_swiginit", Dwg_AcDs_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Header_version_set", _wrap_Dwg_Header_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_version_get", _wrap_Dwg_Header_version_get, METH_O, NULL},
	 { "Dwg_Header_from_version_set", _wrap_Dwg_Header_from_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_from_version_get", _wrap_Dwg_Header_from_version_get, METH_O, NULL},
	 { "Dwg_Header_is_maint_set", _wrap_Dwg_Header_is_maint_set, METH_VARARGS, NULL},
	 { "Dwg_Header_is_maint_get", _wrap_Dwg_Header_is_maint_get, METH_O, NULL},
	 { "Dwg_Header_zero_one_or_three_set", _wrap_Dwg_Header_zero_one_or_three_set, METH_VARARGS, NULL},
	 { "Dwg_Header_zero_one_or_three_get", _wrap_Dwg_Header_zero_one_or_three_get, METH_O, NULL},
	 { "Dwg_Header_numentity_sections_set", _wrap_Dwg_Header_numentity_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Header_numentity_sections_get", _wrap_Dwg_Header_numentity_sections_get, METH_O, NULL},
	 { "Dwg_Header_numheader_vars_set", _wrap_Dwg_Header_numheader_vars_set, METH_VARARGS, NULL},
	 { "Dwg_Header_numheader_vars_get", _wrap_Dwg_Header_numheader_vars_get, METH_O, NULL},
	 { "Dwg_Header_thumbnail_address_set", _wrap_Dwg_Header_thumbnail_address_set, METH_VARARGS, NULL},
	 { "Dwg_Header_thumbnail_address_get", _wrap_Dwg_Header_thumbnail_address_get, METH_O, NULL},
	 { "Dwg_Header_dwg_version_set", _wrap_Dwg_Header_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_dwg_version_get", _wrap_Dwg_Header_dwg_version_get, METH_O, NULL},
	 { "Dwg_Header_maint_version_set", _wrap_Dwg_Header_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_maint_version_get", _wrap_Dwg_Header_maint_version_get, METH_O, NULL},
	 { "Dwg_Header_entities_start_set", _wrap_Dwg_Header_entities_start_set, METH_VARARGS, NULL},
	 { "Dwg_Header_entities_start_get", _wrap_Dwg_Header_entities_start_get, METH_O, NULL},
	 { "Dwg_Header_entities_end_set", _wrap_Dwg_Header_entities_end_set, METH_VARARGS, NULL},
	 { "Dwg_Header_entities_end_get", _wrap_Dwg_Header_entities_end_get, METH_O, NULL},
	 { "Dwg_Header_blocks_start_set", _wrap_Dwg_Header_blocks_start_set, METH_VARARGS, NULL},
	 { "Dwg_Header_blocks_start_get", _wrap_Dwg_Header_blocks_start_get, METH_O, NULL},
	 { "Dwg_Header_blocks_size_set", _wrap_Dwg_Header_blocks_size_set, METH_VARARGS, NULL},
	 { "Dwg_Header_blocks_size_get", _wrap_Dwg_Header_blocks_size_get, METH_O, NULL},
	 { "Dwg_Header_extras_start_set", _wrap_Dwg_Header_extras_start_set, METH_VARARGS, NULL},
	 { "Dwg_Header_extras_start_get", _wrap_Dwg_Header_extras_start_get, METH_O, NULL},
	 { "Dwg_Header_extras_size_set", _wrap_Dwg_Header_extras_size_set, METH_VARARGS, NULL},
	 { "Dwg_Header_extras_size_get", _wrap_Dwg_Header_extras_size_get, METH_O, NULL},
	 { "Dwg_Header_codepage_set", _wrap_Dwg_Header_codepage_set, METH_VARARGS, NULL},
	 { "Dwg_Header_codepage_get", _wrap_Dwg_Header_codepage_get, METH_O, NULL},
	 { "Dwg_Header_unknown_0_set", _wrap_Dwg_Header_unknown_0_set, METH_VARARGS, NULL},
	 { "Dwg_Header_unknown_0_get", _wrap_Dwg_Header_unknown_0_get, METH_O, NULL},
	 { "Dwg_Header_app_dwg_version_set", _wrap_Dwg_Header_app_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_app_dwg_version_get", _wrap_Dwg_Header_app_dwg_version_get, METH_O, NULL},
	 { "Dwg_Header_app_maint_version_set", _wrap_Dwg_Header_app_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_Header_app_maint_version_get", _wrap_Dwg_Header_app_maint_version_get, METH_O, NULL},
	 { "Dwg_Header_security_type_set", _wrap_Dwg_Header_security_type_set, METH_VARARGS, NULL},
	 { "Dwg_Header_security_type_get", _wrap_Dwg_Header_security_type_get, METH_O, NULL},
	 { "Dwg_Header_rl_1c_address_set", _wrap_Dwg_Header_rl_1c_address_set, METH_VARARGS, NULL},
	 { "Dwg_Header_rl_1c_address_get", _wrap_Dwg_Header_rl_1c_address_get, METH_O, NULL},
	 { "Dwg_Header_summaryinfo_address_set", _wrap_Dwg_Header_summaryinfo_address_set, METH_VARARGS, NULL},
	 { "Dwg_Header_summaryinfo_address_get", _wrap_Dwg_Header_summaryinfo_address_get, METH_O, NULL},
	 { "Dwg_Header_vbaproj_address_set", _wrap_Dwg_Header_vbaproj_address_set, METH_VARARGS, NULL},
	 { "Dwg_Header_vbaproj_address_get", _wrap_Dwg_Header_vbaproj_address_get, METH_O, NULL},
	 { "Dwg_Header_r2004_header_address_set", _wrap_Dwg_Header_r2004_header_address_set, METH_VARARGS, NULL},
	 { "Dwg_Header_r2004_header_address_get", _wrap_Dwg_Header_r2004_header_address_get, METH_O, NULL},
	 { "Dwg_Header_sections_set", _wrap_Dwg_Header_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Header_sections_get", _wrap_Dwg_Header_sections_get, METH_O, NULL},
	 { "Dwg_Header_num_sections_set", _wrap_Dwg_Header_num_sections_set, METH_VARARGS, NULL},
	 { "Dwg_Header_num_sections_get", _wrap_Dwg_Header_num_sections_get, METH_O, NULL},
	 { "Dwg_Header_section_set", _wrap_Dwg_Header_section_set, METH_VARARGS, NULL},
	 { "Dwg_Header_section_get", _wrap_Dwg_Header_section_get, METH_O, NULL},
	 { "Dwg_Header_section_infohdr_set", _wrap_Dwg_Header_section_infohdr_set, METH_VARARGS, NULL},
	 { "Dwg_Header_section_infohdr_get", _wrap_Dwg_Header_section_infohdr_get, METH_O, NULL},
	 { "Dwg_Header_section_info_set", _wrap_Dwg_Header_section_info_set, METH_VARARGS, NULL},
	 { "Dwg_Header_section_info_get", _wrap_Dwg_Header_section_info_get, METH_O, NULL},
	 { "new_Dwg_Header", _wrap_new_Dwg_Header, METH_NOARGS, NULL},
	 { "delete_Dwg_Header", _wrap_delete_Dwg_Header, METH_O, NULL},
	 { "Dwg_Header_swigregister", Dwg_Header_swigregister, METH_O, NULL},
	 { "Dwg_Header_swiginit", Dwg_Header_swiginit, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_header_size_set", _wrap_Dwg_R2007_Header_header_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_header_size_get", _wrap_Dwg_R2007_Header_header_size_get, METH_O, NULL},
	 { "Dwg_R2007_Header_file_size_set", _wrap_Dwg_R2007_Header_file_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_file_size_get", _wrap_Dwg_R2007_Header_file_size_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_compressed_set", _wrap_Dwg_R2007_Header_pages_map_crc_compressed_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_compressed_get", _wrap_Dwg_R2007_Header_pages_map_crc_compressed_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_correction_set", _wrap_Dwg_R2007_Header_pages_map_correction_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_correction_get", _wrap_Dwg_R2007_Header_pages_map_correction_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_seed_set", _wrap_Dwg_R2007_Header_pages_map_crc_seed_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_seed_get", _wrap_Dwg_R2007_Header_pages_map_crc_seed_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map2_offset_set", _wrap_Dwg_R2007_Header_pages_map2_offset_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map2_offset_get", _wrap_Dwg_R2007_Header_pages_map2_offset_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map2_id_set", _wrap_Dwg_R2007_Header_pages_map2_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map2_id_get", _wrap_Dwg_R2007_Header_pages_map2_id_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_offset_set", _wrap_Dwg_R2007_Header_pages_map_offset_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_offset_get", _wrap_Dwg_R2007_Header_pages_map_offset_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_id_set", _wrap_Dwg_R2007_Header_pages_map_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_id_get", _wrap_Dwg_R2007_Header_pages_map_id_get, METH_O, NULL},
	 { "Dwg_R2007_Header_header2_offset_set", _wrap_Dwg_R2007_Header_header2_offset_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_header2_offset_get", _wrap_Dwg_R2007_Header_header2_offset_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_size_comp_set", _wrap_Dwg_R2007_Header_pages_map_size_comp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_size_comp_get", _wrap_Dwg_R2007_Header_pages_map_size_comp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_size_uncomp_set", _wrap_Dwg_R2007_Header_pages_map_size_uncomp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_size_uncomp_get", _wrap_Dwg_R2007_Header_pages_map_size_uncomp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_amount_set", _wrap_Dwg_R2007_Header_pages_amount_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_amount_get", _wrap_Dwg_R2007_Header_pages_amount_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_maxid_set", _wrap_Dwg_R2007_Header_pages_maxid_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_maxid_get", _wrap_Dwg_R2007_Header_pages_maxid_get, METH_O, NULL},
	 { "Dwg_R2007_Header_unknown1_set", _wrap_Dwg_R2007_Header_unknown1_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_unknown1_get", _wrap_Dwg_R2007_Header_unknown1_get, METH_O, NULL},
	 { "Dwg_R2007_Header_unknown2_set", _wrap_Dwg_R2007_Header_unknown2_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_unknown2_get", _wrap_Dwg_R2007_Header_unknown2_get, METH_O, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_uncomp_set", _wrap_Dwg_R2007_Header_pages_map_crc_uncomp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_pages_map_crc_uncomp_get", _wrap_Dwg_R2007_Header_pages_map_crc_uncomp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_unknown3_set", _wrap_Dwg_R2007_Header_unknown3_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_unknown3_get", _wrap_Dwg_R2007_Header_unknown3_get, METH_O, NULL},
	 { "Dwg_R2007_Header_unknown4_set", _wrap_Dwg_R2007_Header_unknown4_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_unknown4_get", _wrap_Dwg_R2007_Header_unknown4_get, METH_O, NULL},
	 { "Dwg_R2007_Header_unknown5_set", _wrap_Dwg_R2007_Header_unknown5_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_unknown5_get", _wrap_Dwg_R2007_Header_unknown5_get, METH_O, NULL},
	 { "Dwg_R2007_Header_num_sections_set", _wrap_Dwg_R2007_Header_num_sections_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_num_sections_get", _wrap_Dwg_R2007_Header_num_sections_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_uncomp_set", _wrap_Dwg_R2007_Header_sections_map_crc_uncomp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_uncomp_get", _wrap_Dwg_R2007_Header_sections_map_crc_uncomp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_size_comp_set", _wrap_Dwg_R2007_Header_sections_map_size_comp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_size_comp_get", _wrap_Dwg_R2007_Header_sections_map_size_comp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map2_id_set", _wrap_Dwg_R2007_Header_sections_map2_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map2_id_get", _wrap_Dwg_R2007_Header_sections_map2_id_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_id_set", _wrap_Dwg_R2007_Header_sections_map_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_id_get", _wrap_Dwg_R2007_Header_sections_map_id_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_size_uncomp_set", _wrap_Dwg_R2007_Header_sections_map_size_uncomp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_size_uncomp_get", _wrap_Dwg_R2007_Header_sections_map_size_uncomp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_comp_set", _wrap_Dwg_R2007_Header_sections_map_crc_comp_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_comp_get", _wrap_Dwg_R2007_Header_sections_map_crc_comp_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_correction_set", _wrap_Dwg_R2007_Header_sections_map_correction_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_correction_get", _wrap_Dwg_R2007_Header_sections_map_correction_get, METH_O, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_seed_set", _wrap_Dwg_R2007_Header_sections_map_crc_seed_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_sections_map_crc_seed_get", _wrap_Dwg_R2007_Header_sections_map_crc_seed_get, METH_O, NULL},
	 { "Dwg_R2007_Header_stream_version_set", _wrap_Dwg_R2007_Header_stream_version_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_stream_version_get", _wrap_Dwg_R2007_Header_stream_version_get, METH_O, NULL},
	 { "Dwg_R2007_Header_crc_seed_set", _wrap_Dwg_R2007_Header_crc_seed_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_crc_seed_get", _wrap_Dwg_R2007_Header_crc_seed_get, METH_O, NULL},
	 { "Dwg_R2007_Header_crc_seed_encoded_set", _wrap_Dwg_R2007_Header_crc_seed_encoded_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_crc_seed_encoded_get", _wrap_Dwg_R2007_Header_crc_seed_encoded_get, METH_O, NULL},
	 { "Dwg_R2007_Header_random_seed_set", _wrap_Dwg_R2007_Header_random_seed_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_random_seed_get", _wrap_Dwg_R2007_Header_random_seed_get, METH_O, NULL},
	 { "Dwg_R2007_Header_header_crc_set", _wrap_Dwg_R2007_Header_header_crc_set, METH_VARARGS, NULL},
	 { "Dwg_R2007_Header_header_crc_get", _wrap_Dwg_R2007_Header_header_crc_get, METH_O, NULL},
	 { "new_Dwg_R2007_Header", _wrap_new_Dwg_R2007_Header, METH_NOARGS, NULL},
	 { "delete_Dwg_R2007_Header", _wrap_delete_Dwg_R2007_Header, METH_O, NULL},
	 { "Dwg_R2007_Header_swigregister", Dwg_R2007_Header_swigregister, METH_O, NULL},
	 { "Dwg_R2007_Header_swiginit", Dwg_R2007_Header_swiginit, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_file_ID_string_set", _wrap_Dwg_R2004_Header_file_ID_string_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_file_ID_string_get", _wrap_Dwg_R2004_Header_file_ID_string_get, METH_O, NULL},
	 { "Dwg_R2004_Header_header_address_set", _wrap_Dwg_R2004_Header_header_address_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_header_address_get", _wrap_Dwg_R2004_Header_header_address_get, METH_O, NULL},
	 { "Dwg_R2004_Header_header_size_set", _wrap_Dwg_R2004_Header_header_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_header_size_get", _wrap_Dwg_R2004_Header_header_size_get, METH_O, NULL},
	 { "Dwg_R2004_Header_x04_set", _wrap_Dwg_R2004_Header_x04_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_x04_get", _wrap_Dwg_R2004_Header_x04_get, METH_O, NULL},
	 { "Dwg_R2004_Header_root_tree_node_gap_set", _wrap_Dwg_R2004_Header_root_tree_node_gap_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_root_tree_node_gap_get", _wrap_Dwg_R2004_Header_root_tree_node_gap_get, METH_O, NULL},
	 { "Dwg_R2004_Header_lowermost_left_tree_node_gap_set", _wrap_Dwg_R2004_Header_lowermost_left_tree_node_gap_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_lowermost_left_tree_node_gap_get", _wrap_Dwg_R2004_Header_lowermost_left_tree_node_gap_get, METH_O, NULL},
	 { "Dwg_R2004_Header_lowermost_right_tree_node_gap_set", _wrap_Dwg_R2004_Header_lowermost_right_tree_node_gap_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_lowermost_right_tree_node_gap_get", _wrap_Dwg_R2004_Header_lowermost_right_tree_node_gap_get, METH_O, NULL},
	 { "Dwg_R2004_Header_unknown_long_set", _wrap_Dwg_R2004_Header_unknown_long_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_unknown_long_get", _wrap_Dwg_R2004_Header_unknown_long_get, METH_O, NULL},
	 { "Dwg_R2004_Header_last_section_id_set", _wrap_Dwg_R2004_Header_last_section_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_last_section_id_get", _wrap_Dwg_R2004_Header_last_section_id_get, METH_O, NULL},
	 { "Dwg_R2004_Header_last_section_address_set", _wrap_Dwg_R2004_Header_last_section_address_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_last_section_address_get", _wrap_Dwg_R2004_Header_last_section_address_get, METH_O, NULL},
	 { "Dwg_R2004_Header_secondheader_address_set", _wrap_Dwg_R2004_Header_secondheader_address_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_secondheader_address_get", _wrap_Dwg_R2004_Header_secondheader_address_get, METH_O, NULL},
	 { "Dwg_R2004_Header_numgaps_set", _wrap_Dwg_R2004_Header_numgaps_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_numgaps_get", _wrap_Dwg_R2004_Header_numgaps_get, METH_O, NULL},
	 { "Dwg_R2004_Header_numsections_set", _wrap_Dwg_R2004_Header_numsections_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_numsections_get", _wrap_Dwg_R2004_Header_numsections_get, METH_O, NULL},
	 { "Dwg_R2004_Header_x20_set", _wrap_Dwg_R2004_Header_x20_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_x20_get", _wrap_Dwg_R2004_Header_x20_get, METH_O, NULL},
	 { "Dwg_R2004_Header_x80_set", _wrap_Dwg_R2004_Header_x80_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_x80_get", _wrap_Dwg_R2004_Header_x80_get, METH_O, NULL},
	 { "Dwg_R2004_Header_x40_set", _wrap_Dwg_R2004_Header_x40_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_x40_get", _wrap_Dwg_R2004_Header_x40_get, METH_O, NULL},
	 { "Dwg_R2004_Header_section_map_id_set", _wrap_Dwg_R2004_Header_section_map_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_section_map_id_get", _wrap_Dwg_R2004_Header_section_map_id_get, METH_O, NULL},
	 { "Dwg_R2004_Header_section_map_address_set", _wrap_Dwg_R2004_Header_section_map_address_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_section_map_address_get", _wrap_Dwg_R2004_Header_section_map_address_get, METH_O, NULL},
	 { "Dwg_R2004_Header_section_info_id_set", _wrap_Dwg_R2004_Header_section_info_id_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_section_info_id_get", _wrap_Dwg_R2004_Header_section_info_id_get, METH_O, NULL},
	 { "Dwg_R2004_Header_section_array_size_set", _wrap_Dwg_R2004_Header_section_array_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_section_array_size_get", _wrap_Dwg_R2004_Header_section_array_size_get, METH_O, NULL},
	 { "Dwg_R2004_Header_gap_array_size_set", _wrap_Dwg_R2004_Header_gap_array_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_gap_array_size_get", _wrap_Dwg_R2004_Header_gap_array_size_get, METH_O, NULL},
	 { "Dwg_R2004_Header_crc32_set", _wrap_Dwg_R2004_Header_crc32_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_crc32_get", _wrap_Dwg_R2004_Header_crc32_get, METH_O, NULL},
	 { "Dwg_R2004_Header_padding_set", _wrap_Dwg_R2004_Header_padding_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_padding_get", _wrap_Dwg_R2004_Header_padding_get, METH_O, NULL},
	 { "Dwg_R2004_Header_section_type_set", _wrap_Dwg_R2004_Header_section_type_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_section_type_get", _wrap_Dwg_R2004_Header_section_type_get, METH_O, NULL},
	 { "Dwg_R2004_Header_decomp_data_size_set", _wrap_Dwg_R2004_Header_decomp_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_decomp_data_size_get", _wrap_Dwg_R2004_Header_decomp_data_size_get, METH_O, NULL},
	 { "Dwg_R2004_Header_comp_data_size_set", _wrap_Dwg_R2004_Header_comp_data_size_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_comp_data_size_get", _wrap_Dwg_R2004_Header_comp_data_size_get, METH_O, NULL},
	 { "Dwg_R2004_Header_compression_type_set", _wrap_Dwg_R2004_Header_compression_type_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_compression_type_get", _wrap_Dwg_R2004_Header_compression_type_get, METH_O, NULL},
	 { "Dwg_R2004_Header_checksum_set", _wrap_Dwg_R2004_Header_checksum_set, METH_VARARGS, NULL},
	 { "Dwg_R2004_Header_checksum_get", _wrap_Dwg_R2004_Header_checksum_get, METH_O, NULL},
	 { "new_Dwg_R2004_Header", _wrap_new_Dwg_R2004_Header, METH_NOARGS, NULL},
	 { "delete_Dwg_R2004_Header", _wrap_delete_Dwg_R2004_Header, METH_O, NULL},
	 { "Dwg_R2004_Header_swigregister", Dwg_R2004_Header_swigregister, METH_O, NULL},
	 { "Dwg_R2004_Header_swiginit", Dwg_R2004_Header_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_aux_intro_set", _wrap_Dwg_AuxHeader_aux_intro_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_aux_intro_get", _wrap_Dwg_AuxHeader_aux_intro_get, METH_O, NULL},
	 { "Dwg_AuxHeader_dwg_version_set", _wrap_Dwg_AuxHeader_dwg_version_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_dwg_version_get", _wrap_Dwg_AuxHeader_dwg_version_get, METH_O, NULL},
	 { "Dwg_AuxHeader_maint_version_set", _wrap_Dwg_AuxHeader_maint_version_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_maint_version_get", _wrap_Dwg_AuxHeader_maint_version_get, METH_O, NULL},
	 { "Dwg_AuxHeader_numsaves_set", _wrap_Dwg_AuxHeader_numsaves_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_numsaves_get", _wrap_Dwg_AuxHeader_numsaves_get, METH_O, NULL},
	 { "Dwg_AuxHeader_minus_1_set", _wrap_Dwg_AuxHeader_minus_1_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_minus_1_get", _wrap_Dwg_AuxHeader_minus_1_get, METH_O, NULL},
	 { "Dwg_AuxHeader_numsaves_1_set", _wrap_Dwg_AuxHeader_numsaves_1_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_numsaves_1_get", _wrap_Dwg_AuxHeader_numsaves_1_get, METH_O, NULL},
	 { "Dwg_AuxHeader_numsaves_2_set", _wrap_Dwg_AuxHeader_numsaves_2_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_numsaves_2_get", _wrap_Dwg_AuxHeader_numsaves_2_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_set", _wrap_Dwg_AuxHeader_zero_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_get", _wrap_Dwg_AuxHeader_zero_get, METH_O, NULL},
	 { "Dwg_AuxHeader_dwg_version_1_set", _wrap_Dwg_AuxHeader_dwg_version_1_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_dwg_version_1_get", _wrap_Dwg_AuxHeader_dwg_version_1_get, METH_O, NULL},
	 { "Dwg_AuxHeader_maint_version_1_set", _wrap_Dwg_AuxHeader_maint_version_1_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_maint_version_1_get", _wrap_Dwg_AuxHeader_maint_version_1_get, METH_O, NULL},
	 { "Dwg_AuxHeader_dwg_version_2_set", _wrap_Dwg_AuxHeader_dwg_version_2_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_dwg_version_2_get", _wrap_Dwg_AuxHeader_dwg_version_2_get, METH_O, NULL},
	 { "Dwg_AuxHeader_maint_version_2_set", _wrap_Dwg_AuxHeader_maint_version_2_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_maint_version_2_get", _wrap_Dwg_AuxHeader_maint_version_2_get, METH_O, NULL},
	 { "Dwg_AuxHeader_unknown_6rs_set", _wrap_Dwg_AuxHeader_unknown_6rs_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_unknown_6rs_get", _wrap_Dwg_AuxHeader_unknown_6rs_get, METH_O, NULL},
	 { "Dwg_AuxHeader_unknown_5rl_set", _wrap_Dwg_AuxHeader_unknown_5rl_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_unknown_5rl_get", _wrap_Dwg_AuxHeader_unknown_5rl_get, METH_O, NULL},
	 { "Dwg_AuxHeader_TDCREATE_set", _wrap_Dwg_AuxHeader_TDCREATE_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_TDCREATE_get", _wrap_Dwg_AuxHeader_TDCREATE_get, METH_O, NULL},
	 { "Dwg_AuxHeader_TDUPDATE_set", _wrap_Dwg_AuxHeader_TDUPDATE_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_TDUPDATE_get", _wrap_Dwg_AuxHeader_TDUPDATE_get, METH_O, NULL},
	 { "Dwg_AuxHeader_HANDSEED_set", _wrap_Dwg_AuxHeader_HANDSEED_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_HANDSEED_get", _wrap_Dwg_AuxHeader_HANDSEED_get, METH_O, NULL},
	 { "Dwg_AuxHeader_plot_stamp_set", _wrap_Dwg_AuxHeader_plot_stamp_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_plot_stamp_get", _wrap_Dwg_AuxHeader_plot_stamp_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_1_set", _wrap_Dwg_AuxHeader_zero_1_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_1_get", _wrap_Dwg_AuxHeader_zero_1_get, METH_O, NULL},
	 { "Dwg_AuxHeader_numsaves_3_set", _wrap_Dwg_AuxHeader_numsaves_3_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_numsaves_3_get", _wrap_Dwg_AuxHeader_numsaves_3_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_2_set", _wrap_Dwg_AuxHeader_zero_2_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_2_get", _wrap_Dwg_AuxHeader_zero_2_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_3_set", _wrap_Dwg_AuxHeader_zero_3_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_3_get", _wrap_Dwg_AuxHeader_zero_3_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_4_set", _wrap_Dwg_AuxHeader_zero_4_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_4_get", _wrap_Dwg_AuxHeader_zero_4_get, METH_O, NULL},
	 { "Dwg_AuxHeader_numsaves_4_set", _wrap_Dwg_AuxHeader_numsaves_4_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_numsaves_4_get", _wrap_Dwg_AuxHeader_numsaves_4_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_5_set", _wrap_Dwg_AuxHeader_zero_5_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_5_get", _wrap_Dwg_AuxHeader_zero_5_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_6_set", _wrap_Dwg_AuxHeader_zero_6_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_6_get", _wrap_Dwg_AuxHeader_zero_6_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_7_set", _wrap_Dwg_AuxHeader_zero_7_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_7_get", _wrap_Dwg_AuxHeader_zero_7_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_8_set", _wrap_Dwg_AuxHeader_zero_8_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_8_get", _wrap_Dwg_AuxHeader_zero_8_get, METH_O, NULL},
	 { "Dwg_AuxHeader_zero_18_set", _wrap_Dwg_AuxHeader_zero_18_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_zero_18_get", _wrap_Dwg_AuxHeader_zero_18_get, METH_O, NULL},
	 { "Dwg_AuxHeader_num_auxheader_variables_set", _wrap_Dwg_AuxHeader_num_auxheader_variables_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_num_auxheader_variables_get", _wrap_Dwg_AuxHeader_num_auxheader_variables_get, METH_O, NULL},
	 { "Dwg_AuxHeader_auxheader_size_set", _wrap_Dwg_AuxHeader_auxheader_size_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_auxheader_size_get", _wrap_Dwg_AuxHeader_auxheader_size_get, METH_O, NULL},
	 { "Dwg_AuxHeader_entities_start_set", _wrap_Dwg_AuxHeader_entities_start_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_entities_start_get", _wrap_Dwg_AuxHeader_entities_start_get, METH_O, NULL},
	 { "Dwg_AuxHeader_entities_end_set", _wrap_Dwg_AuxHeader_entities_end_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_entities_end_get", _wrap_Dwg_AuxHeader_entities_end_get, METH_O, NULL},
	 { "Dwg_AuxHeader_blocks_start_set", _wrap_Dwg_AuxHeader_blocks_start_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_blocks_start_get", _wrap_Dwg_AuxHeader_blocks_start_get, METH_O, NULL},
	 { "Dwg_AuxHeader_extras_start_set", _wrap_Dwg_AuxHeader_extras_start_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_extras_start_get", _wrap_Dwg_AuxHeader_extras_start_get, METH_O, NULL},
	 { "Dwg_AuxHeader_auxheader_address_set", _wrap_Dwg_AuxHeader_auxheader_address_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_auxheader_address_get", _wrap_Dwg_AuxHeader_auxheader_address_get, METH_O, NULL},
	 { "Dwg_AuxHeader_num_aux_tables_set", _wrap_Dwg_AuxHeader_num_aux_tables_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_num_aux_tables_get", _wrap_Dwg_AuxHeader_num_aux_tables_get, METH_O, NULL},
	 { "Dwg_AuxHeader_R11_HANDLING_set", _wrap_Dwg_AuxHeader_R11_HANDLING_set, METH_VARARGS, NULL},
	 { "Dwg_AuxHeader_R11_HANDLING_get", _wrap_Dwg_AuxHeader_R11_HANDLING_get, METH_O, NULL},
	 { "new_Dwg_AuxHeader", _wrap_new_Dwg_AuxHeader, METH_NOARGS, NULL},
	 { "delete_Dwg_AuxHeader", _wrap_delete_Dwg_AuxHeader, METH_O, NULL},
	 { "Dwg_AuxHeader_swigregister", Dwg_AuxHeader_swigregister, METH_O, NULL},
	 { "Dwg_AuxHeader_swiginit", Dwg_AuxHeader_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_TITLE_set", _wrap_Dwg_SummaryInfo_TITLE_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_TITLE_get", _wrap_Dwg_SummaryInfo_TITLE_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_SUBJECT_set", _wrap_Dwg_SummaryInfo_SUBJECT_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_SUBJECT_get", _wrap_Dwg_SummaryInfo_SUBJECT_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_AUTHOR_set", _wrap_Dwg_SummaryInfo_AUTHOR_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_AUTHOR_get", _wrap_Dwg_SummaryInfo_AUTHOR_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_KEYWORDS_set", _wrap_Dwg_SummaryInfo_KEYWORDS_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_KEYWORDS_get", _wrap_Dwg_SummaryInfo_KEYWORDS_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_COMMENTS_set", _wrap_Dwg_SummaryInfo_COMMENTS_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_COMMENTS_get", _wrap_Dwg_SummaryInfo_COMMENTS_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_LASTSAVEDBY_set", _wrap_Dwg_SummaryInfo_LASTSAVEDBY_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_LASTSAVEDBY_get", _wrap_Dwg_SummaryInfo_LASTSAVEDBY_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_REVISIONNUMBER_set", _wrap_Dwg_SummaryInfo_REVISIONNUMBER_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_REVISIONNUMBER_get", _wrap_Dwg_SummaryInfo_REVISIONNUMBER_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_HYPERLINKBASE_set", _wrap_Dwg_SummaryInfo_HYPERLINKBASE_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_HYPERLINKBASE_get", _wrap_Dwg_SummaryInfo_HYPERLINKBASE_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_TDINDWG_set", _wrap_Dwg_SummaryInfo_TDINDWG_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_TDINDWG_get", _wrap_Dwg_SummaryInfo_TDINDWG_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_TDCREATE_set", _wrap_Dwg_SummaryInfo_TDCREATE_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_TDCREATE_get", _wrap_Dwg_SummaryInfo_TDCREATE_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_TDUPDATE_set", _wrap_Dwg_SummaryInfo_TDUPDATE_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_TDUPDATE_get", _wrap_Dwg_SummaryInfo_TDUPDATE_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_num_props_set", _wrap_Dwg_SummaryInfo_num_props_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_num_props_get", _wrap_Dwg_SummaryInfo_num_props_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_props_set", _wrap_Dwg_SummaryInfo_props_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_props_get", _wrap_Dwg_SummaryInfo_props_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_unknown1_set", _wrap_Dwg_SummaryInfo_unknown1_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_unknown1_get", _wrap_Dwg_SummaryInfo_unknown1_get, METH_O, NULL},
	 { "Dwg_SummaryInfo_unknown2_set", _wrap_Dwg_SummaryInfo_unknown2_set, METH_VARARGS, NULL},
	 { "Dwg_SummaryInfo_unknown2_get", _wrap_Dwg_SummaryInfo_unknown2_get, METH_O, NULL},
	 { "new_Dwg_SummaryInfo", _wrap_new_Dwg_SummaryInfo, METH_NOARGS, NULL},
	 { "delete_Dwg_SummaryInfo", _wrap_delete_Dwg_SummaryInfo, METH_O, NULL},
	 { "Dwg_SummaryInfo_swigregister", Dwg_SummaryInfo_swigregister, METH_O, NULL},
	 { "Dwg_SummaryInfo_swiginit", Dwg_SummaryInfo_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_class_version_set", _wrap_Dwg_AppInfo_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_class_version_get", _wrap_Dwg_AppInfo_class_version_get, METH_O, NULL},
	 { "Dwg_AppInfo_num_strings_set", _wrap_Dwg_AppInfo_num_strings_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_num_strings_get", _wrap_Dwg_AppInfo_num_strings_get, METH_O, NULL},
	 { "Dwg_AppInfo_appinfo_name_set", _wrap_Dwg_AppInfo_appinfo_name_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_appinfo_name_get", _wrap_Dwg_AppInfo_appinfo_name_get, METH_O, NULL},
	 { "Dwg_AppInfo_version_checksum_set", _wrap_Dwg_AppInfo_version_checksum_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_version_checksum_get", _wrap_Dwg_AppInfo_version_checksum_get, METH_O, NULL},
	 { "Dwg_AppInfo_comment_checksum_set", _wrap_Dwg_AppInfo_comment_checksum_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_comment_checksum_get", _wrap_Dwg_AppInfo_comment_checksum_get, METH_O, NULL},
	 { "Dwg_AppInfo_product_checksum_set", _wrap_Dwg_AppInfo_product_checksum_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_product_checksum_get", _wrap_Dwg_AppInfo_product_checksum_get, METH_O, NULL},
	 { "Dwg_AppInfo_version_set", _wrap_Dwg_AppInfo_version_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_version_get", _wrap_Dwg_AppInfo_version_get, METH_O, NULL},
	 { "Dwg_AppInfo_comment_set", _wrap_Dwg_AppInfo_comment_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_comment_get", _wrap_Dwg_AppInfo_comment_get, METH_O, NULL},
	 { "Dwg_AppInfo_product_info_set", _wrap_Dwg_AppInfo_product_info_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfo_product_info_get", _wrap_Dwg_AppInfo_product_info_get, METH_O, NULL},
	 { "new_Dwg_AppInfo", _wrap_new_Dwg_AppInfo, METH_NOARGS, NULL},
	 { "delete_Dwg_AppInfo", _wrap_delete_Dwg_AppInfo, METH_O, NULL},
	 { "Dwg_AppInfo_swigregister", Dwg_AppInfo_swigregister, METH_O, NULL},
	 { "Dwg_AppInfo_swiginit", Dwg_AppInfo_swiginit, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_num_features_set", _wrap_Dwg_FileDepList_num_features_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_num_features_get", _wrap_Dwg_FileDepList_num_features_get, METH_O, NULL},
	 { "Dwg_FileDepList_features_set", _wrap_Dwg_FileDepList_features_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_features_get", _wrap_Dwg_FileDepList_features_get, METH_O, NULL},
	 { "Dwg_FileDepList_num_files_set", _wrap_Dwg_FileDepList_num_files_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_num_files_get", _wrap_Dwg_FileDepList_num_files_get, METH_O, NULL},
	 { "Dwg_FileDepList_files_set", _wrap_Dwg_FileDepList_files_set, METH_VARARGS, NULL},
	 { "Dwg_FileDepList_files_get", _wrap_Dwg_FileDepList_files_get, METH_O, NULL},
	 { "new_Dwg_FileDepList", _wrap_new_Dwg_FileDepList, METH_NOARGS, NULL},
	 { "delete_Dwg_FileDepList", _wrap_delete_Dwg_FileDepList, METH_O, NULL},
	 { "Dwg_FileDepList_swigregister", Dwg_FileDepList_swigregister, METH_O, NULL},
	 { "Dwg_FileDepList_swiginit", Dwg_FileDepList_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Security_unknown_1_set", _wrap_Dwg_Security_unknown_1_set, METH_VARARGS, NULL},
	 { "Dwg_Security_unknown_1_get", _wrap_Dwg_Security_unknown_1_get, METH_O, NULL},
	 { "Dwg_Security_unknown_2_set", _wrap_Dwg_Security_unknown_2_set, METH_VARARGS, NULL},
	 { "Dwg_Security_unknown_2_get", _wrap_Dwg_Security_unknown_2_get, METH_O, NULL},
	 { "Dwg_Security_unknown_3_set", _wrap_Dwg_Security_unknown_3_set, METH_VARARGS, NULL},
	 { "Dwg_Security_unknown_3_get", _wrap_Dwg_Security_unknown_3_get, METH_O, NULL},
	 { "Dwg_Security_crypto_id_set", _wrap_Dwg_Security_crypto_id_set, METH_VARARGS, NULL},
	 { "Dwg_Security_crypto_id_get", _wrap_Dwg_Security_crypto_id_get, METH_O, NULL},
	 { "Dwg_Security_crypto_name_set", _wrap_Dwg_Security_crypto_name_set, METH_VARARGS, NULL},
	 { "Dwg_Security_crypto_name_get", _wrap_Dwg_Security_crypto_name_get, METH_O, NULL},
	 { "Dwg_Security_algo_id_set", _wrap_Dwg_Security_algo_id_set, METH_VARARGS, NULL},
	 { "Dwg_Security_algo_id_get", _wrap_Dwg_Security_algo_id_get, METH_O, NULL},
	 { "Dwg_Security_key_len_set", _wrap_Dwg_Security_key_len_set, METH_VARARGS, NULL},
	 { "Dwg_Security_key_len_get", _wrap_Dwg_Security_key_len_get, METH_O, NULL},
	 { "Dwg_Security_encr_size_set", _wrap_Dwg_Security_encr_size_set, METH_VARARGS, NULL},
	 { "Dwg_Security_encr_size_get", _wrap_Dwg_Security_encr_size_get, METH_O, NULL},
	 { "Dwg_Security_encr_buffer_set", _wrap_Dwg_Security_encr_buffer_set, METH_VARARGS, NULL},
	 { "Dwg_Security_encr_buffer_get", _wrap_Dwg_Security_encr_buffer_get, METH_O, NULL},
	 { "new_Dwg_Security", _wrap_new_Dwg_Security, METH_NOARGS, NULL},
	 { "delete_Dwg_Security", _wrap_delete_Dwg_Security, METH_O, NULL},
	 { "Dwg_Security_swigregister", Dwg_Security_swigregister, METH_O, NULL},
	 { "Dwg_Security_swiginit", Dwg_Security_swiginit, METH_VARARGS, NULL},
	 { "Dwg_VBAProject_size_set", _wrap_Dwg_VBAProject_size_set, METH_VARARGS, NULL},
	 { "Dwg_VBAProject_size_get", _wrap_Dwg_VBAProject_size_get, METH_O, NULL},
	 { "Dwg_VBAProject_unknown_bits_set", _wrap_Dwg_VBAProject_unknown_bits_set, METH_VARARGS, NULL},
	 { "Dwg_VBAProject_unknown_bits_get", _wrap_Dwg_VBAProject_unknown_bits_get, METH_O, NULL},
	 { "new_Dwg_VBAProject", _wrap_new_Dwg_VBAProject, METH_NOARGS, NULL},
	 { "delete_Dwg_VBAProject", _wrap_delete_Dwg_VBAProject, METH_O, NULL},
	 { "Dwg_VBAProject_swigregister", Dwg_VBAProject_swigregister, METH_O, NULL},
	 { "Dwg_VBAProject_swiginit", Dwg_VBAProject_swiginit, METH_VARARGS, NULL},
	 { "Dwg_AppInfoHistory_size_set", _wrap_Dwg_AppInfoHistory_size_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfoHistory_size_get", _wrap_Dwg_AppInfoHistory_size_get, METH_O, NULL},
	 { "Dwg_AppInfoHistory_unknown_bits_set", _wrap_Dwg_AppInfoHistory_unknown_bits_set, METH_VARARGS, NULL},
	 { "Dwg_AppInfoHistory_unknown_bits_get", _wrap_Dwg_AppInfoHistory_unknown_bits_get, METH_O, NULL},
	 { "new_Dwg_AppInfoHistory", _wrap_new_Dwg_AppInfoHistory, METH_NOARGS, NULL},
	 { "delete_Dwg_AppInfoHistory", _wrap_delete_Dwg_AppInfoHistory, METH_O, NULL},
	 { "Dwg_AppInfoHistory_swigregister", Dwg_AppInfoHistory_swigregister, METH_O, NULL},
	 { "Dwg_AppInfoHistory_swiginit", Dwg_AppInfoHistory_swiginit, METH_VARARGS, NULL},
	 { "Dwg_RevHistory_class_version_set", _wrap_Dwg_RevHistory_class_version_set, METH_VARARGS, NULL},
	 { "Dwg_RevHistory_class_version_get", _wrap_Dwg_RevHistory_class_version_get, METH_O, NULL},
	 { "Dwg_RevHistory_class_minor_set", _wrap_Dwg_RevHistory_class_minor_set, METH_VARARGS, NULL},
	 { "Dwg_RevHistory_class_minor_get", _wrap_Dwg_RevHistory_class_minor_get, METH_O, NULL},
	 { "Dwg_RevHistory_num_histories_set", _wrap_Dwg_RevHistory_num_histories_set, METH_VARARGS, NULL},
	 { "Dwg_RevHistory_num_histories_get", _wrap_Dwg_RevHistory_num_histories_get, METH_O, NULL},
	 { "Dwg_RevHistory_histories_set", _wrap_Dwg_RevHistory_histories_set, METH_VARARGS, NULL},
	 { "Dwg_RevHistory_histories_get", _wrap_Dwg_RevHistory_histories_get, METH_O, NULL},
	 { "new_Dwg_RevHistory", _wrap_new_Dwg_RevHistory, METH_NOARGS, NULL},
	 { "delete_Dwg_RevHistory", _wrap_delete_Dwg_RevHistory, METH_O, NULL},
	 { "Dwg_RevHistory_swigregister", Dwg_RevHistory_swigregister, METH_O, NULL},
	 { "Dwg_RevHistory_swiginit", Dwg_RevHistory_swiginit, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_zero_set", _wrap_Dwg_ObjFreeSpace_zero_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_zero_get", _wrap_Dwg_ObjFreeSpace_zero_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_numhandles_set", _wrap_Dwg_ObjFreeSpace_numhandles_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_numhandles_get", _wrap_Dwg_ObjFreeSpace_numhandles_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_TDUPDATE_set", _wrap_Dwg_ObjFreeSpace_TDUPDATE_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_TDUPDATE_get", _wrap_Dwg_ObjFreeSpace_TDUPDATE_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_objects_address_set", _wrap_Dwg_ObjFreeSpace_objects_address_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_objects_address_get", _wrap_Dwg_ObjFreeSpace_objects_address_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_numnums_set", _wrap_Dwg_ObjFreeSpace_numnums_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_numnums_get", _wrap_Dwg_ObjFreeSpace_numnums_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_max32_set", _wrap_Dwg_ObjFreeSpace_max32_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_max32_get", _wrap_Dwg_ObjFreeSpace_max32_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_max64_set", _wrap_Dwg_ObjFreeSpace_max64_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_max64_get", _wrap_Dwg_ObjFreeSpace_max64_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_maxtbl_set", _wrap_Dwg_ObjFreeSpace_maxtbl_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_maxtbl_get", _wrap_Dwg_ObjFreeSpace_maxtbl_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_maxrl_set", _wrap_Dwg_ObjFreeSpace_maxrl_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_maxrl_get", _wrap_Dwg_ObjFreeSpace_maxrl_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_max32_hi_set", _wrap_Dwg_ObjFreeSpace_max32_hi_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_max32_hi_get", _wrap_Dwg_ObjFreeSpace_max32_hi_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_max64_hi_set", _wrap_Dwg_ObjFreeSpace_max64_hi_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_max64_hi_get", _wrap_Dwg_ObjFreeSpace_max64_hi_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_maxtbl_hi_set", _wrap_Dwg_ObjFreeSpace_maxtbl_hi_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_maxtbl_hi_get", _wrap_Dwg_ObjFreeSpace_maxtbl_hi_get, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_maxrl_hi_set", _wrap_Dwg_ObjFreeSpace_maxrl_hi_set, METH_VARARGS, NULL},
	 { "Dwg_ObjFreeSpace_maxrl_hi_get", _wrap_Dwg_ObjFreeSpace_maxrl_hi_get, METH_O, NULL},
	 { "new_Dwg_ObjFreeSpace", _wrap_new_Dwg_ObjFreeSpace, METH_NOARGS, NULL},
	 { "delete_Dwg_ObjFreeSpace", _wrap_delete_Dwg_ObjFreeSpace, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_swigregister", Dwg_ObjFreeSpace_swigregister, METH_O, NULL},
	 { "Dwg_ObjFreeSpace_swiginit", Dwg_ObjFreeSpace_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Template_description_set", _wrap_Dwg_Template_description_set, METH_VARARGS, NULL},
	 { "Dwg_Template_description_get", _wrap_Dwg_Template_description_get, METH_O, NULL},
	 { "Dwg_Template_MEASUREMENT_set", _wrap_Dwg_Template_MEASUREMENT_set, METH_VARARGS, NULL},
	 { "Dwg_Template_MEASUREMENT_get", _wrap_Dwg_Template_MEASUREMENT_get, METH_O, NULL},
	 { "new_Dwg_Template", _wrap_new_Dwg_Template, METH_NOARGS, NULL},
	 { "delete_Dwg_Template", _wrap_delete_Dwg_Template, METH_O, NULL},
	 { "Dwg_Template_swigregister", Dwg_Template_swigregister, METH_O, NULL},
	 { "Dwg_Template_swiginit", Dwg_Template_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Sections_nr_set", _wrap_Dwg_SecondHeader_Sections_nr_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Sections_nr_get", _wrap_Dwg_SecondHeader_Sections_nr_get, METH_O, NULL},
	 { "Dwg_SecondHeader_Sections_address_set", _wrap_Dwg_SecondHeader_Sections_address_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Sections_address_get", _wrap_Dwg_SecondHeader_Sections_address_get, METH_O, NULL},
	 { "Dwg_SecondHeader_Sections_size_set", _wrap_Dwg_SecondHeader_Sections_size_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Sections_size_get", _wrap_Dwg_SecondHeader_Sections_size_get, METH_O, NULL},
	 { "new_Dwg_SecondHeader_Sections", _wrap_new_Dwg_SecondHeader_Sections, METH_NOARGS, NULL},
	 { "delete_Dwg_SecondHeader_Sections", _wrap_delete_Dwg_SecondHeader_Sections, METH_O, NULL},
	 { "Dwg_SecondHeader_Sections_swigregister", Dwg_SecondHeader_Sections_swigregister, METH_O, NULL},
	 { "Dwg_SecondHeader_Sections_swiginit", Dwg_SecondHeader_Sections_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Handles_num_hdl_set", _wrap_Dwg_SecondHeader_Handles_num_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Handles_num_hdl_get", _wrap_Dwg_SecondHeader_Handles_num_hdl_get, METH_O, NULL},
	 { "Dwg_SecondHeader_Handles_nr_set", _wrap_Dwg_SecondHeader_Handles_nr_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Handles_nr_get", _wrap_Dwg_SecondHeader_Handles_nr_get, METH_O, NULL},
	 { "Dwg_SecondHeader_Handles_hdl_set", _wrap_Dwg_SecondHeader_Handles_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Handles_hdl_get", _wrap_Dwg_SecondHeader_Handles_hdl_get, METH_O, NULL},
	 { "Dwg_SecondHeader_Handles_name_set", _wrap_Dwg_SecondHeader_Handles_name_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_Handles_name_get", _wrap_Dwg_SecondHeader_Handles_name_get, METH_O, NULL},
	 { "new_Dwg_SecondHeader_Handles", _wrap_new_Dwg_SecondHeader_Handles, METH_NOARGS, NULL},
	 { "delete_Dwg_SecondHeader_Handles", _wrap_delete_Dwg_SecondHeader_Handles, METH_O, NULL},
	 { "Dwg_SecondHeader_Handles_swigregister", Dwg_SecondHeader_Handles_swigregister, METH_O, NULL},
	 { "Dwg_SecondHeader_Handles_swiginit", Dwg_SecondHeader_Handles_swiginit, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_size_set", _wrap_Dwg_SecondHeader_size_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_size_get", _wrap_Dwg_SecondHeader_size_get, METH_O, NULL},
	 { "Dwg_SecondHeader_address_set", _wrap_Dwg_SecondHeader_address_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_address_get", _wrap_Dwg_SecondHeader_address_get, METH_O, NULL},
	 { "Dwg_SecondHeader_version_set", _wrap_Dwg_SecondHeader_version_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_version_get", _wrap_Dwg_SecondHeader_version_get, METH_O, NULL},
	 { "Dwg_SecondHeader_is_maint_set", _wrap_Dwg_SecondHeader_is_maint_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_is_maint_get", _wrap_Dwg_SecondHeader_is_maint_get, METH_O, NULL},
	 { "Dwg_SecondHeader_zero_one_or_three_set", _wrap_Dwg_SecondHeader_zero_one_or_three_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_zero_one_or_three_get", _wrap_Dwg_SecondHeader_zero_one_or_three_get, METH_O, NULL},
	 { "Dwg_SecondHeader_dwg_versions_set", _wrap_Dwg_SecondHeader_dwg_versions_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_dwg_versions_get", _wrap_Dwg_SecondHeader_dwg_versions_get, METH_O, NULL},
	 { "Dwg_SecondHeader_codepage_set", _wrap_Dwg_SecondHeader_codepage_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_codepage_get", _wrap_Dwg_SecondHeader_codepage_get, METH_O, NULL},
	 { "Dwg_SecondHeader_num_sections_set", _wrap_Dwg_SecondHeader_num_sections_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_num_sections_get", _wrap_Dwg_SecondHeader_num_sections_get, METH_O, NULL},
	 { "Dwg_SecondHeader_sections_set", _wrap_Dwg_SecondHeader_sections_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_sections_get", _wrap_Dwg_SecondHeader_sections_get, METH_O, NULL},
	 { "Dwg_SecondHeader_num_handles_set", _wrap_Dwg_SecondHeader_num_handles_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_num_handles_get", _wrap_Dwg_SecondHeader_num_handles_get, METH_O, NULL},
	 { "Dwg_SecondHeader_handles_set", _wrap_Dwg_SecondHeader_handles_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_handles_get", _wrap_Dwg_SecondHeader_handles_get, METH_O, NULL},
	 { "Dwg_SecondHeader_crc_set", _wrap_Dwg_SecondHeader_crc_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_crc_get", _wrap_Dwg_SecondHeader_crc_get, METH_O, NULL},
	 { "Dwg_SecondHeader_junk_r14_set", _wrap_Dwg_SecondHeader_junk_r14_set, METH_VARARGS, NULL},
	 { "Dwg_SecondHeader_junk_r14_get", _wrap_Dwg_SecondHeader_junk_r14_get, METH_O, NULL},
	 { "new_Dwg_SecondHeader", _wrap_new_Dwg_SecondHeader, METH_NOARGS, NULL},
	 { "delete_Dwg_SecondHeader", _wrap_delete_Dwg_SecondHeader, METH_O, NULL},
	 { "Dwg_SecondHeader_swigregister", Dwg_SecondHeader_swigregister, METH_O, NULL},
	 { "Dwg_SecondHeader_swiginit", Dwg_SecondHeader_swiginit, METH_VARARGS, NULL},
	 { "Dwg_Data_header_set", _wrap_Dwg_Data_header_set, METH_VARARGS, NULL},
	 { "Dwg_Data_header_get", _wrap_Dwg_Data_header_get, METH_O, NULL},
	 { "Dwg_Data_num_classes_set", _wrap_Dwg_Data_num_classes_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_classes_get", _wrap_Dwg_Data_num_classes_get, METH_O, NULL},
	 { "Dwg_Data_dwg_class_set", _wrap_Dwg_Data_dwg_class_set, METH_VARARGS, NULL},
	 { "Dwg_Data_dwg_class_get", _wrap_Dwg_Data_dwg_class_get, METH_O, NULL},
	 { "Dwg_Data_num_objects_set", _wrap_Dwg_Data_num_objects_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_objects_get", _wrap_Dwg_Data_num_objects_get, METH_O, NULL},
	 { "Dwg_Data_num_alloced_objects_set", _wrap_Dwg_Data_num_alloced_objects_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_alloced_objects_get", _wrap_Dwg_Data_num_alloced_objects_get, METH_O, NULL},
	 { "Dwg_Data_object_set", _wrap_Dwg_Data_object_set, METH_VARARGS, NULL},
	 { "Dwg_Data_object_get", _wrap_Dwg_Data_object_get, METH_O, NULL},
	 { "Dwg_Data_num_entities_set", _wrap_Dwg_Data_num_entities_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_entities_get", _wrap_Dwg_Data_num_entities_get, METH_O, NULL},
	 { "Dwg_Data_num_object_refs_set", _wrap_Dwg_Data_num_object_refs_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_object_refs_get", _wrap_Dwg_Data_num_object_refs_get, METH_O, NULL},
	 { "Dwg_Data_cur_index_set", _wrap_Dwg_Data_cur_index_set, METH_VARARGS, NULL},
	 { "Dwg_Data_cur_index_get", _wrap_Dwg_Data_cur_index_get, METH_O, NULL},
	 { "Dwg_Data_object_ref_set", _wrap_Dwg_Data_object_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Data_object_ref_get", _wrap_Dwg_Data_object_ref_get, METH_O, NULL},
	 { "Dwg_Data_object_map_set", _wrap_Dwg_Data_object_map_set, METH_VARARGS, NULL},
	 { "Dwg_Data_object_map_get", _wrap_Dwg_Data_object_map_get, METH_O, NULL},
	 { "Dwg_Data_dirty_refs_set", _wrap_Dwg_Data_dirty_refs_set, METH_VARARGS, NULL},
	 { "Dwg_Data_dirty_refs_get", _wrap_Dwg_Data_dirty_refs_get, METH_O, NULL},
	 { "Dwg_Data_opts_set", _wrap_Dwg_Data_opts_set, METH_VARARGS, NULL},
	 { "Dwg_Data_opts_get", _wrap_Dwg_Data_opts_get, METH_O, NULL},
	 { "Dwg_Data_header_vars_set", _wrap_Dwg_Data_header_vars_set, METH_VARARGS, NULL},
	 { "Dwg_Data_header_vars_get", _wrap_Dwg_Data_header_vars_get, METH_O, NULL},
	 { "Dwg_Data_thumbnail_set", _wrap_Dwg_Data_thumbnail_set, METH_VARARGS, NULL},
	 { "Dwg_Data_thumbnail_get", _wrap_Dwg_Data_thumbnail_get, METH_O, NULL},
	 { "Dwg_Data_fhdr_get", _wrap_Dwg_Data_fhdr_get, METH_O, NULL},
	 { "Dwg_Data_mspace_block_set", _wrap_Dwg_Data_mspace_block_set, METH_VARARGS, NULL},
	 { "Dwg_Data_mspace_block_get", _wrap_Dwg_Data_mspace_block_get, METH_O, NULL},
	 { "Dwg_Data_pspace_block_set", _wrap_Dwg_Data_pspace_block_set, METH_VARARGS, NULL},
	 { "Dwg_Data_pspace_block_get", _wrap_Dwg_Data_pspace_block_get, METH_O, NULL},
	 { "Dwg_Data_block_control_set", _wrap_Dwg_Data_block_control_set, METH_VARARGS, NULL},
	 { "Dwg_Data_block_control_get", _wrap_Dwg_Data_block_control_get, METH_O, NULL},
	 { "Dwg_Data_auxheader_set", _wrap_Dwg_Data_auxheader_set, METH_VARARGS, NULL},
	 { "Dwg_Data_auxheader_get", _wrap_Dwg_Data_auxheader_get, METH_O, NULL},
	 { "Dwg_Data_secondheader_set", _wrap_Dwg_Data_secondheader_set, METH_VARARGS, NULL},
	 { "Dwg_Data_secondheader_get", _wrap_Dwg_Data_secondheader_get, METH_O, NULL},
	 { "Dwg_Data_summaryinfo_set", _wrap_Dwg_Data_summaryinfo_set, METH_VARARGS, NULL},
	 { "Dwg_Data_summaryinfo_get", _wrap_Dwg_Data_summaryinfo_get, METH_O, NULL},
	 { "Dwg_Data_appinfo_set", _wrap_Dwg_Data_appinfo_set, METH_VARARGS, NULL},
	 { "Dwg_Data_appinfo_get", _wrap_Dwg_Data_appinfo_get, METH_O, NULL},
	 { "Dwg_Data_filedeplist_set", _wrap_Dwg_Data_filedeplist_set, METH_VARARGS, NULL},
	 { "Dwg_Data_filedeplist_get", _wrap_Dwg_Data_filedeplist_get, METH_O, NULL},
	 { "Dwg_Data_security_set", _wrap_Dwg_Data_security_set, METH_VARARGS, NULL},
	 { "Dwg_Data_security_get", _wrap_Dwg_Data_security_get, METH_O, NULL},
	 { "Dwg_Data_vbaproject_set", _wrap_Dwg_Data_vbaproject_set, METH_VARARGS, NULL},
	 { "Dwg_Data_vbaproject_get", _wrap_Dwg_Data_vbaproject_get, METH_O, NULL},
	 { "Dwg_Data_appinfohistory_set", _wrap_Dwg_Data_appinfohistory_set, METH_VARARGS, NULL},
	 { "Dwg_Data_appinfohistory_get", _wrap_Dwg_Data_appinfohistory_get, METH_O, NULL},
	 { "Dwg_Data_revhistory_set", _wrap_Dwg_Data_revhistory_set, METH_VARARGS, NULL},
	 { "Dwg_Data_revhistory_get", _wrap_Dwg_Data_revhistory_get, METH_O, NULL},
	 { "Dwg_Data_objfreespace_set", _wrap_Dwg_Data_objfreespace_set, METH_VARARGS, NULL},
	 { "Dwg_Data_objfreespace_get", _wrap_Dwg_Data_objfreespace_get, METH_O, NULL},
	 { "Dwg_Data_Template_set", _wrap_Dwg_Data_Template_set, METH_VARARGS, NULL},
	 { "Dwg_Data_Template_get", _wrap_Dwg_Data_Template_get, METH_O, NULL},
	 { "Dwg_Data_acds_set", _wrap_Dwg_Data_acds_set, METH_VARARGS, NULL},
	 { "Dwg_Data_acds_get", _wrap_Dwg_Data_acds_get, METH_O, NULL},
	 { "Dwg_Data_layout_type_set", _wrap_Dwg_Data_layout_type_set, METH_VARARGS, NULL},
	 { "Dwg_Data_layout_type_get", _wrap_Dwg_Data_layout_type_get, METH_O, NULL},
	 { "Dwg_Data_num_acis_sab_hdl_set", _wrap_Dwg_Data_num_acis_sab_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_acis_sab_hdl_get", _wrap_Dwg_Data_num_acis_sab_hdl_get, METH_O, NULL},
	 { "Dwg_Data_acis_sab_hdl_set", _wrap_Dwg_Data_acis_sab_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_Data_acis_sab_hdl_get", _wrap_Dwg_Data_acis_sab_hdl_get, METH_O, NULL},
	 { "Dwg_Data_next_hdl_set", _wrap_Dwg_Data_next_hdl_set, METH_VARARGS, NULL},
	 { "Dwg_Data_next_hdl_get", _wrap_Dwg_Data_next_hdl_get, METH_O, NULL},
	 { "Dwg_Data_prev_entity_index_set", _wrap_Dwg_Data_prev_entity_index_set, METH_VARARGS, NULL},
	 { "Dwg_Data_prev_entity_index_get", _wrap_Dwg_Data_prev_entity_index_get, METH_O, NULL},
	 { "Dwg_Data_object_ordered_ref_set", _wrap_Dwg_Data_object_ordered_ref_set, METH_VARARGS, NULL},
	 { "Dwg_Data_object_ordered_ref_get", _wrap_Dwg_Data_object_ordered_ref_get, METH_O, NULL},
	 { "Dwg_Data_num_object_ordered_refs_set", _wrap_Dwg_Data_num_object_ordered_refs_set, METH_VARARGS, NULL},
	 { "Dwg_Data_num_object_ordered_refs_get", _wrap_Dwg_Data_num_object_ordered_refs_get, METH_O, NULL},
	 { "new_Dwg_Data", _wrap_new_Dwg_Data, METH_NOARGS, NULL},
	 { "delete_Dwg_Data", _wrap_delete_Dwg_Data, METH_O, NULL},
	 { "Dwg_Data_swigregister", Dwg_Data_swigregister, METH_O, NULL},
	 { "Dwg_Data_swiginit", Dwg_Data_swiginit, METH_VARARGS, NULL},
	 { "_dwg_struct_fhdr_r2004_header_set", _wrap__dwg_struct_fhdr_r2004_header_set, METH_VARARGS, NULL},
	 { "_dwg_struct_fhdr_r2004_header_get", _wrap__dwg_struct_fhdr_r2004_header_get, METH_O, NULL},
	 { "_dwg_struct_fhdr_r2007_file_header_set", _wrap__dwg_struct_fhdr_r2007_file_header_set, METH_VARARGS, NULL},
	 { "_dwg_struct_fhdr_r2007_file_header_get", _wrap__dwg_struct_fhdr_r2007_file_header_get, METH_O, NULL},
	 { "new__dwg_struct_fhdr", _wrap_new__dwg_struct_fhdr, METH_NOARGS, NULL},
	 { "delete__dwg_struct_fhdr", _wrap_delete__dwg_struct_fhdr, METH_O, NULL},
	 { "_dwg_struct_fhdr_swigregister", _dwg_struct_fhdr_swigregister, METH_O, NULL},
	 { "_dwg_struct_fhdr_swiginit", _dwg_struct_fhdr_swiginit, METH_VARARGS, NULL},
	 { "dwg_read_file", _wrap_dwg_read_file, METH_VARARGS, NULL},
	 { "dxf_read_file", _wrap_dxf_read_file, METH_VARARGS, NULL},
	 { "dwg_write_file", _wrap_dwg_write_file, METH_VARARGS, NULL},
	 { "dwg_bmp", _wrap_dwg_bmp, METH_VARARGS, NULL},
	 { "dxf_cvt_lweight", _wrap_dxf_cvt_lweight, METH_O, NULL},
	 { "dxf_revcvt_lweight", _wrap_dxf_revcvt_lweight, METH_O, NULL},
	 { "dwg_ctrl_table", _wrap_dwg_ctrl_table, METH_VARARGS, NULL},
	 { "dwg_find_tablehandle", _wrap_dwg_find_tablehandle, METH_VARARGS, NULL},
	 { "dwg_find_tablehandle_index", _wrap_dwg_find_tablehandle_index, METH_VARARGS, NULL},
	 { "dwg_handle_name", _wrap_dwg_handle_name, METH_VARARGS, NULL},
	 { "dwg_find_table_control", _wrap_dwg_find_table_control, METH_VARARGS, NULL},
	 { "dwg_find_dictionary", _wrap_dwg_find_dictionary, METH_VARARGS, NULL},
	 { "dwg_find_dicthandle", _wrap_dwg_find_dicthandle, METH_VARARGS, NULL},
	 { "dwg_find_dicthandle_objname", _wrap_dwg_find_dicthandle_objname, METH_VARARGS, NULL},
	 { "dwg_find_table_extname", _wrap_dwg_find_table_extname, METH_VARARGS, NULL},
	 { "dwg_variable_dict", _wrap_dwg_variable_dict, METH_VARARGS, NULL},
	 { "dwg_model_x_min", _wrap_dwg_model_x_min, METH_O, NULL},
	 { "dwg_model_x_max", _wrap_dwg_model_x_max, METH_O, NULL},
	 { "dwg_model_y_min", _wrap_dwg_model_y_min, METH_O, NULL},
	 { "dwg_model_y_max", _wrap_dwg_model_y_max, METH_O, NULL},
	 { "dwg_model_z_min", _wrap_dwg_model_z_min, METH_O, NULL},
	 { "dwg_model_z_max", _wrap_dwg_model_z_max, METH_O, NULL},
	 { "dwg_page_x_min", _wrap_dwg_page_x_min, METH_O, NULL},
	 { "dwg_page_x_max", _wrap_dwg_page_x_max, METH_O, NULL},
	 { "dwg_page_y_min", _wrap_dwg_page_y_min, METH_O, NULL},
	 { "dwg_page_y_max", _wrap_dwg_page_y_max, METH_O, NULL},
	 { "dwg_block_control", _wrap_dwg_block_control, METH_O, NULL},
	 { "dwg_model_space_ref", _wrap_dwg_model_space_ref, METH_O, NULL},
	 { "dwg_paper_space_ref", _wrap_dwg_paper_space_ref, METH_O, NULL},
	 { "dwg_model_space_object", _wrap_dwg_model_space_object, METH_O, NULL},
	 { "dwg_paper_space_object", _wrap_dwg_paper_space_object, METH_O, NULL},
	 { "dwg_get_layer_count", _wrap_dwg_get_layer_count, METH_O, NULL},
	 { "dwg_get_layers", _wrap_dwg_get_layers, METH_O, NULL},
	 { "dwg_get_num_objects", _wrap_dwg_get_num_objects, METH_O, NULL},
	 { "dwg_get_object_num_objects", _wrap_dwg_get_object_num_objects, METH_O, NULL},
	 { "dwg_class_is_entity", _wrap_dwg_class_is_entity, METH_O, NULL},
	 { "dwg_obj_is_control", _wrap_dwg_obj_is_control, METH_O, NULL},
	 { "dwg_obj_is_table", _wrap_dwg_obj_is_table, METH_O, NULL},
	 { "dwg_obj_is_subentity", _wrap_dwg_obj_is_subentity, METH_O, NULL},
	 { "dwg_obj_has_subentity", _wrap_dwg_obj_has_subentity, METH_O, NULL},
	 { "dwg_obj_is_3dsolid", _wrap_dwg_obj_is_3dsolid, METH_O, NULL},
	 { "dwg_obj_is_acsh", _wrap_dwg_obj_is_acsh, METH_O, NULL},
	 { "dwg_get_num_entities", _wrap_dwg_get_num_entities, METH_O, NULL},
	 { "dwg_get_entities", _wrap_dwg_get_entities, METH_O, NULL},
	 { "dwg_get_entity_layer", _wrap_dwg_get_entity_layer, METH_O, NULL},
	 { "dwg_next_object", _wrap_dwg_next_object, METH_O, NULL},
	 { "dwg_next_entity", _wrap_dwg_next_entity, METH_O, NULL},
	 { "dwg_next_handle", _wrap_dwg_next_handle, METH_O, NULL},
	 { "dwg_next_handseed", _wrap_dwg_next_handseed, METH_O, NULL},
	 { "dwg_ref_object", _wrap_dwg_ref_object, METH_VARARGS, NULL},
	 { "dwg_ref_object_relative", _wrap_dwg_ref_object_relative, METH_VARARGS, NULL},
	 { "dwg_ref_object_silent", _wrap_dwg_ref_object_silent, METH_VARARGS, NULL},
	 { "get_first_owned_entity", _wrap_get_first_owned_entity, METH_O, NULL},
	 { "get_next_owned_entity", _wrap_get_next_owned_entity, METH_VARARGS, NULL},
	 { "get_first_owned_subentity", _wrap_get_first_owned_subentity, METH_O, NULL},
	 { "get_next_owned_subentity", _wrap_get_next_owned_subentity, METH_VARARGS, NULL},
	 { "get_first_owned_block", _wrap_get_first_owned_block, METH_O, NULL},
	 { "get_last_owned_block", _wrap_get_last_owned_block, METH_O, NULL},
	 { "get_next_owned_block", _wrap_get_next_owned_block, METH_VARARGS, NULL},
	 { "get_next_owned_block_entity", _wrap_get_next_owned_block_entity, METH_VARARGS, NULL},
	 { "dwg_get_first_object", _wrap_dwg_get_first_object, METH_VARARGS, NULL},
	 { "dwg_get_next_object", _wrap_dwg_get_next_object, METH_VARARGS, NULL},
	 { "dwg_resolve_handle", _wrap_dwg_resolve_handle, METH_VARARGS, NULL},
	 { "dwg_resolve_handle_silent", _wrap_dwg_resolve_handle_silent, METH_VARARGS, NULL},
	 { "dwg_resolve_handleref", _wrap_dwg_resolve_handleref, METH_VARARGS, NULL},
	 { "dwg_resolve_jump", _wrap_dwg_resolve_jump, METH_O, NULL},
	 { "dwg_section_type", _wrap_dwg_section_type, METH_O, NULL},
	 { "dwg_section_wtype", _wrap_dwg_section_wtype, METH_O, NULL},
	 { "dwg_section_name", _wrap_dwg_section_name, METH_VARARGS, NULL},
	 { "dwg_resbuf_value_type", _wrap_dwg_resbuf_value_type, METH_O, NULL},
	 { "dwg_free", _wrap_dwg_free, METH_O, NULL},
	 { "dwg_free_object", _wrap_dwg_free_object, METH_O, NULL},
	 { "dwg_new_ref", _wrap_dwg_new_ref, METH_O, NULL},
	 { "dwg_add_handle", _wrap_dwg_add_handle, METH_VARARGS, NULL},
	 { "dwg_add_handleref", _wrap_dwg_add_handleref, METH_VARARGS, NULL},
	 { "dwg_dup_handleref", _wrap_dwg_dup_handleref, METH_VARARGS, NULL},
	 { "dwg_add_handleref_free", _wrap_dwg_add_handleref_free, METH_VARARGS, NULL},
	 { "dwg_version_type", _wrap_dwg_version_type, METH_O, NULL},
	 { "dwg_version_as", _wrap_dwg_version_as, METH_O, NULL},
	 { "dwg_version_hdr_type", _wrap_dwg_version_hdr_type, METH_O, NULL},
	 { "dwg_supports_eed", _wrap_dwg_supports_eed, METH_O, NULL},
	 { "dwg_supports_obj", _wrap_dwg_supports_obj, METH_VARARGS, NULL},
	 { "dwg_errstrings", _wrap_dwg_errstrings, METH_O, NULL},
	 { "dwg_encrypt_SAT1", _wrap_dwg_encrypt_SAT1, METH_VARARGS, NULL},
	 { "dwg_convert_SAB_to_SAT1", _wrap_dwg_convert_SAB_to_SAT1, METH_O, NULL},
	 { "Dwg_RGB_Palette_r_set", _wrap_Dwg_RGB_Palette_r_set, METH_VARARGS, NULL},
	 { "Dwg_RGB_Palette_r_get", _wrap_Dwg_RGB_Palette_r_get, METH_O, NULL},
	 { "Dwg_RGB_Palette_g_set", _wrap_Dwg_RGB_Palette_g_set, METH_VARARGS, NULL},
	 { "Dwg_RGB_Palette_g_get", _wrap_Dwg_RGB_Palette_g_get, METH_O, NULL},
	 { "Dwg_RGB_Palette_b_set", _wrap_Dwg_RGB_Palette_b_set, METH_VARARGS, NULL},
	 { "Dwg_RGB_Palette_b_get", _wrap_Dwg_RGB_Palette_b_get, METH_O, NULL},
	 { "new_Dwg_RGB_Palette", _wrap_new_Dwg_RGB_Palette, METH_NOARGS, NULL},
	 { "delete_Dwg_RGB_Palette", _wrap_delete_Dwg_RGB_Palette, METH_O, NULL},
	 { "Dwg_RGB_Palette_swigregister", Dwg_RGB_Palette_swigregister, METH_O, NULL},
	 { "Dwg_RGB_Palette_swiginit", Dwg_RGB_Palette_swiginit, METH_VARARGS, NULL},
	 { "dwg_rgb_palette", _wrap_dwg_rgb_palette, METH_NOARGS, NULL},
	 { "dwg_rgb_palette_index", _wrap_dwg_rgb_palette_index, METH_O, NULL},
	 { "dwg_find_color_index", _wrap_dwg_find_color_index, METH_O, NULL},
	 { "dwg_add_object", _wrap_dwg_add_object, METH_O, NULL},
	 { "dwg_object_name", _wrap_dwg_object_name, METH_VARARGS, NULL},
	 { "dwg_setup__3DFACE", _wrap_dwg_setup__3DFACE, METH_O, NULL},
	 { "dwg_setup__3DSOLID", _wrap_dwg_setup__3DSOLID, METH_O, NULL},
	 { "dwg_setup_ARC", _wrap_dwg_setup_ARC, METH_O, NULL},
	 { "dwg_setup_ATTDEF", _wrap_dwg_setup_ATTDEF, METH_O, NULL},
	 { "dwg_setup_ATTRIB", _wrap_dwg_setup_ATTRIB, METH_O, NULL},
	 { "dwg_setup_BLOCK", _wrap_dwg_setup_BLOCK, METH_O, NULL},
	 { "dwg_setup_BODY", _wrap_dwg_setup_BODY, METH_O, NULL},
	 { "dwg_setup_CIRCLE", _wrap_dwg_setup_CIRCLE, METH_O, NULL},
	 { "dwg_setup_DIMENSION_ALIGNED", _wrap_dwg_setup_DIMENSION_ALIGNED, METH_O, NULL},
	 { "dwg_setup_DIMENSION_ANG2LN", _wrap_dwg_setup_DIMENSION_ANG2LN, METH_O, NULL},
	 { "dwg_setup_DIMENSION_ANG3PT", _wrap_dwg_setup_DIMENSION_ANG3PT, METH_O, NULL},
	 { "dwg_setup_DIMENSION_DIAMETER", _wrap_dwg_setup_DIMENSION_DIAMETER, METH_O, NULL},
	 { "dwg_setup_DIMENSION_LINEAR", _wrap_dwg_setup_DIMENSION_LINEAR, METH_O, NULL},
	 { "dwg_setup_DIMENSION_ORDINATE", _wrap_dwg_setup_DIMENSION_ORDINATE, METH_O, NULL},
	 { "dwg_setup_DIMENSION_RADIUS", _wrap_dwg_setup_DIMENSION_RADIUS, METH_O, NULL},
	 { "dwg_setup_ELLIPSE", _wrap_dwg_setup_ELLIPSE, METH_O, NULL},
	 { "dwg_setup_ENDBLK", _wrap_dwg_setup_ENDBLK, METH_O, NULL},
	 { "dwg_setup_INSERT", _wrap_dwg_setup_INSERT, METH_O, NULL},
	 { "dwg_setup_LEADER", _wrap_dwg_setup_LEADER, METH_O, NULL},
	 { "dwg_setup_LINE", _wrap_dwg_setup_LINE, METH_O, NULL},
	 { "dwg_setup_LOAD", _wrap_dwg_setup_LOAD, METH_O, NULL},
	 { "dwg_setup_MINSERT", _wrap_dwg_setup_MINSERT, METH_O, NULL},
	 { "dwg_setup_MLINE", _wrap_dwg_setup_MLINE, METH_O, NULL},
	 { "dwg_setup_MTEXT", _wrap_dwg_setup_MTEXT, METH_O, NULL},
	 { "dwg_setup_OLEFRAME", _wrap_dwg_setup_OLEFRAME, METH_O, NULL},
	 { "dwg_setup_POINT", _wrap_dwg_setup_POINT, METH_O, NULL},
	 { "dwg_setup_POLYLINE_2D", _wrap_dwg_setup_POLYLINE_2D, METH_O, NULL},
	 { "dwg_setup_POLYLINE_3D", _wrap_dwg_setup_POLYLINE_3D, METH_O, NULL},
	 { "dwg_setup_POLYLINE_MESH", _wrap_dwg_setup_POLYLINE_MESH, METH_O, NULL},
	 { "dwg_setup_POLYLINE_PFACE", _wrap_dwg_setup_POLYLINE_PFACE, METH_O, NULL},
	 { "dwg_setup_PROXY_ENTITY", _wrap_dwg_setup_PROXY_ENTITY, METH_O, NULL},
	 { "dwg_setup_RAY", _wrap_dwg_setup_RAY, METH_O, NULL},
	 { "dwg_setup_REGION", _wrap_dwg_setup_REGION, METH_O, NULL},
	 { "dwg_setup_SEQEND", _wrap_dwg_setup_SEQEND, METH_O, NULL},
	 { "dwg_setup_SHAPE", _wrap_dwg_setup_SHAPE, METH_O, NULL},
	 { "dwg_setup_SOLID", _wrap_dwg_setup_SOLID, METH_O, NULL},
	 { "dwg_setup_SPLINE", _wrap_dwg_setup_SPLINE, METH_O, NULL},
	 { "dwg_setup_TEXT", _wrap_dwg_setup_TEXT, METH_O, NULL},
	 { "dwg_setup_TOLERANCE", _wrap_dwg_setup_TOLERANCE, METH_O, NULL},
	 { "dwg_setup_TRACE", _wrap_dwg_setup_TRACE, METH_O, NULL},
	 { "dwg_setup_UNKNOWN_ENT", _wrap_dwg_setup_UNKNOWN_ENT, METH_O, NULL},
	 { "dwg_setup_VERTEX_2D", _wrap_dwg_setup_VERTEX_2D, METH_O, NULL},
	 { "dwg_setup_VERTEX_3D", _wrap_dwg_setup_VERTEX_3D, METH_O, NULL},
	 { "dwg_setup_VERTEX_MESH", _wrap_dwg_setup_VERTEX_MESH, METH_O, NULL},
	 { "dwg_setup_VERTEX_PFACE", _wrap_dwg_setup_VERTEX_PFACE, METH_O, NULL},
	 { "dwg_setup_VERTEX_PFACE_FACE", _wrap_dwg_setup_VERTEX_PFACE_FACE, METH_O, NULL},
	 { "dwg_setup_VIEWPORT", _wrap_dwg_setup_VIEWPORT, METH_O, NULL},
	 { "dwg_setup_XLINE", _wrap_dwg_setup_XLINE, METH_O, NULL},
	 { "dwg_setup_APPID", _wrap_dwg_setup_APPID, METH_O, NULL},
	 { "dwg_setup_APPID_CONTROL", _wrap_dwg_setup_APPID_CONTROL, METH_O, NULL},
	 { "dwg_setup_BLOCK_CONTROL", _wrap_dwg_setup_BLOCK_CONTROL, METH_O, NULL},
	 { "dwg_setup_BLOCK_HEADER", _wrap_dwg_setup_BLOCK_HEADER, METH_O, NULL},
	 { "dwg_setup_DICTIONARY", _wrap_dwg_setup_DICTIONARY, METH_O, NULL},
	 { "dwg_setup_DIMSTYLE", _wrap_dwg_setup_DIMSTYLE, METH_O, NULL},
	 { "dwg_setup_DIMSTYLE_CONTROL", _wrap_dwg_setup_DIMSTYLE_CONTROL, METH_O, NULL},
	 { "dwg_setup_DUMMY", _wrap_dwg_setup_DUMMY, METH_O, NULL},
	 { "dwg_setup_LAYER", _wrap_dwg_setup_LAYER, METH_O, NULL},
	 { "dwg_setup_LAYER_CONTROL", _wrap_dwg_setup_LAYER_CONTROL, METH_O, NULL},
	 { "dwg_setup_LONG_TRANSACTION", _wrap_dwg_setup_LONG_TRANSACTION, METH_O, NULL},
	 { "dwg_setup_LTYPE", _wrap_dwg_setup_LTYPE, METH_O, NULL},
	 { "dwg_setup_LTYPE_CONTROL", _wrap_dwg_setup_LTYPE_CONTROL, METH_O, NULL},
	 { "dwg_setup_MLINESTYLE", _wrap_dwg_setup_MLINESTYLE, METH_O, NULL},
	 { "dwg_setup_STYLE", _wrap_dwg_setup_STYLE, METH_O, NULL},
	 { "dwg_setup_STYLE_CONTROL", _wrap_dwg_setup_STYLE_CONTROL, METH_O, NULL},
	 { "dwg_setup_UCS", _wrap_dwg_setup_UCS, METH_O, NULL},
	 { "dwg_setup_UCS_CONTROL", _wrap_dwg_setup_UCS_CONTROL, METH_O, NULL},
	 { "dwg_setup_UNKNOWN_OBJ", _wrap_dwg_setup_UNKNOWN_OBJ, METH_O, NULL},
	 { "dwg_setup_VIEW", _wrap_dwg_setup_VIEW, METH_O, NULL},
	 { "dwg_setup_VIEW_CONTROL", _wrap_dwg_setup_VIEW_CONTROL, METH_O, NULL},
	 { "dwg_setup_VPORT", _wrap_dwg_setup_VPORT, METH_O, NULL},
	 { "dwg_setup_VPORT_CONTROL", _wrap_dwg_setup_VPORT_CONTROL, METH_O, NULL},
	 { "dwg_setup_VX_CONTROL", _wrap_dwg_setup_VX_CONTROL, METH_O, NULL},
	 { "dwg_setup_VX_TABLE_RECORD", _wrap_dwg_setup_VX_TABLE_RECORD, METH_O, NULL},
	 { "dwg_setup__3DLINE", _wrap_dwg_setup__3DLINE, METH_O, NULL},
	 { "dwg_setup_CAMERA", _wrap_dwg_setup_CAMERA, METH_O, NULL},
	 { "dwg_setup_DGNUNDERLAY", _wrap_dwg_setup_DGNUNDERLAY, METH_O, NULL},
	 { "dwg_setup_DWFUNDERLAY", _wrap_dwg_setup_DWFUNDERLAY, METH_O, NULL},
	 { "dwg_setup_ENDREP", _wrap_dwg_setup_ENDREP, METH_O, NULL},
	 { "dwg_setup_HATCH", _wrap_dwg_setup_HATCH, METH_O, NULL},
	 { "dwg_setup_IMAGE", _wrap_dwg_setup_IMAGE, METH_O, NULL},
	 { "dwg_setup_JUMP", _wrap_dwg_setup_JUMP, METH_O, NULL},
	 { "dwg_setup_LIGHT", _wrap_dwg_setup_LIGHT, METH_O, NULL},
	 { "dwg_setup_LWPOLYLINE", _wrap_dwg_setup_LWPOLYLINE, METH_O, NULL},
	 { "dwg_setup_MESH", _wrap_dwg_setup_MESH, METH_O, NULL},
	 { "dwg_setup_MULTILEADER", _wrap_dwg_setup_MULTILEADER, METH_O, NULL},
	 { "dwg_setup_OLE2FRAME", _wrap_dwg_setup_OLE2FRAME, METH_O, NULL},
	 { "dwg_setup_PDFUNDERLAY", _wrap_dwg_setup_PDFUNDERLAY, METH_O, NULL},
	 { "dwg_setup_REPEAT", _wrap_dwg_setup_REPEAT, METH_O, NULL},
	 { "dwg_setup_SECTIONOBJECT", _wrap_dwg_setup_SECTIONOBJECT, METH_O, NULL},
	 { "dwg_setup_WIPEOUT", _wrap_dwg_setup_WIPEOUT, METH_O, NULL},
	 { "dwg_setup_ACSH_BOOLEAN_CLASS", _wrap_dwg_setup_ACSH_BOOLEAN_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_BOX_CLASS", _wrap_dwg_setup_ACSH_BOX_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_CONE_CLASS", _wrap_dwg_setup_ACSH_CONE_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_CYLINDER_CLASS", _wrap_dwg_setup_ACSH_CYLINDER_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_FILLET_CLASS", _wrap_dwg_setup_ACSH_FILLET_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_HISTORY_CLASS", _wrap_dwg_setup_ACSH_HISTORY_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_SPHERE_CLASS", _wrap_dwg_setup_ACSH_SPHERE_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_TORUS_CLASS", _wrap_dwg_setup_ACSH_TORUS_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_WEDGE_CLASS", _wrap_dwg_setup_ACSH_WEDGE_CLASS, METH_O, NULL},
	 { "dwg_setup_ASSOCGEOMDEPENDENCY", _wrap_dwg_setup_ASSOCGEOMDEPENDENCY, METH_O, NULL},
	 { "dwg_setup_ASSOCNETWORK", _wrap_dwg_setup_ASSOCNETWORK, METH_O, NULL},
	 { "dwg_setup_BLOCKALIGNMENTGRIP", _wrap_dwg_setup_BLOCKALIGNMENTGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKALIGNMENTPARAMETER", _wrap_dwg_setup_BLOCKALIGNMENTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKBASEPOINTPARAMETER", _wrap_dwg_setup_BLOCKBASEPOINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKFLIPACTION", _wrap_dwg_setup_BLOCKFLIPACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKFLIPGRIP", _wrap_dwg_setup_BLOCKFLIPGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKFLIPPARAMETER", _wrap_dwg_setup_BLOCKFLIPPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKGRIPLOCATIONCOMPONENT", _wrap_dwg_setup_BLOCKGRIPLOCATIONCOMPONENT, METH_O, NULL},
	 { "dwg_setup_BLOCKLINEARGRIP", _wrap_dwg_setup_BLOCKLINEARGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKLOOKUPGRIP", _wrap_dwg_setup_BLOCKLOOKUPGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKMOVEACTION", _wrap_dwg_setup_BLOCKMOVEACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKROTATEACTION", _wrap_dwg_setup_BLOCKROTATEACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKROTATIONGRIP", _wrap_dwg_setup_BLOCKROTATIONGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKSCALEACTION", _wrap_dwg_setup_BLOCKSCALEACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKVISIBILITYGRIP", _wrap_dwg_setup_BLOCKVISIBILITYGRIP, METH_O, NULL},
	 { "dwg_setup_CELLSTYLEMAP", _wrap_dwg_setup_CELLSTYLEMAP, METH_O, NULL},
	 { "dwg_setup_DETAILVIEWSTYLE", _wrap_dwg_setup_DETAILVIEWSTYLE, METH_O, NULL},
	 { "dwg_setup_DICTIONARYVAR", _wrap_dwg_setup_DICTIONARYVAR, METH_O, NULL},
	 { "dwg_setup_DICTIONARYWDFLT", _wrap_dwg_setup_DICTIONARYWDFLT, METH_O, NULL},
	 { "dwg_setup_DYNAMICBLOCKPURGEPREVENTER", _wrap_dwg_setup_DYNAMICBLOCKPURGEPREVENTER, METH_O, NULL},
	 { "dwg_setup_FIELD", _wrap_dwg_setup_FIELD, METH_O, NULL},
	 { "dwg_setup_FIELDLIST", _wrap_dwg_setup_FIELDLIST, METH_O, NULL},
	 { "dwg_setup_GEODATA", _wrap_dwg_setup_GEODATA, METH_O, NULL},
	 { "dwg_setup_GROUP", _wrap_dwg_setup_GROUP, METH_O, NULL},
	 { "dwg_setup_IDBUFFER", _wrap_dwg_setup_IDBUFFER, METH_O, NULL},
	 { "dwg_setup_IMAGEDEF", _wrap_dwg_setup_IMAGEDEF, METH_O, NULL},
	 { "dwg_setup_IMAGEDEF_REACTOR", _wrap_dwg_setup_IMAGEDEF_REACTOR, METH_O, NULL},
	 { "dwg_setup_INDEX", _wrap_dwg_setup_INDEX, METH_O, NULL},
	 { "dwg_setup_LAYERFILTER", _wrap_dwg_setup_LAYERFILTER, METH_O, NULL},
	 { "dwg_setup_LAYER_INDEX", _wrap_dwg_setup_LAYER_INDEX, METH_O, NULL},
	 { "dwg_setup_LAYOUT", _wrap_dwg_setup_LAYOUT, METH_O, NULL},
	 { "dwg_setup_PLACEHOLDER", _wrap_dwg_setup_PLACEHOLDER, METH_O, NULL},
	 { "dwg_setup_PLOTSETTINGS", _wrap_dwg_setup_PLOTSETTINGS, METH_O, NULL},
	 { "dwg_setup_RASTERVARIABLES", _wrap_dwg_setup_RASTERVARIABLES, METH_O, NULL},
	 { "dwg_setup_RENDERENVIRONMENT", _wrap_dwg_setup_RENDERENVIRONMENT, METH_O, NULL},
	 { "dwg_setup_SCALE", _wrap_dwg_setup_SCALE, METH_O, NULL},
	 { "dwg_setup_SECTIONVIEWSTYLE", _wrap_dwg_setup_SECTIONVIEWSTYLE, METH_O, NULL},
	 { "dwg_setup_SECTION_MANAGER", _wrap_dwg_setup_SECTION_MANAGER, METH_O, NULL},
	 { "dwg_setup_SORTENTSTABLE", _wrap_dwg_setup_SORTENTSTABLE, METH_O, NULL},
	 { "dwg_setup_SPATIAL_FILTER", _wrap_dwg_setup_SPATIAL_FILTER, METH_O, NULL},
	 { "dwg_setup_SUN", _wrap_dwg_setup_SUN, METH_O, NULL},
	 { "dwg_setup_TABLEGEOMETRY", _wrap_dwg_setup_TABLEGEOMETRY, METH_O, NULL},
	 { "dwg_setup_VBA_PROJECT", _wrap_dwg_setup_VBA_PROJECT, METH_O, NULL},
	 { "dwg_setup_VISUALSTYLE", _wrap_dwg_setup_VISUALSTYLE, METH_O, NULL},
	 { "dwg_setup_WIPEOUTVARIABLES", _wrap_dwg_setup_WIPEOUTVARIABLES, METH_O, NULL},
	 { "dwg_setup_XRECORD", _wrap_dwg_setup_XRECORD, METH_O, NULL},
	 { "dwg_setup_PDFDEFINITION", _wrap_dwg_setup_PDFDEFINITION, METH_O, NULL},
	 { "dwg_setup_DGNDEFINITION", _wrap_dwg_setup_DGNDEFINITION, METH_O, NULL},
	 { "dwg_setup_DWFDEFINITION", _wrap_dwg_setup_DWFDEFINITION, METH_O, NULL},
	 { "dwg_setup_ARC_DIMENSION", _wrap_dwg_setup_ARC_DIMENSION, METH_O, NULL},
	 { "dwg_setup_HELIX", _wrap_dwg_setup_HELIX, METH_O, NULL},
	 { "dwg_setup_LARGE_RADIAL_DIMENSION", _wrap_dwg_setup_LARGE_RADIAL_DIMENSION, METH_O, NULL},
	 { "dwg_setup_LAYOUTPRINTCONFIG", _wrap_dwg_setup_LAYOUTPRINTCONFIG, METH_O, NULL},
	 { "dwg_setup_PLANESURFACE", _wrap_dwg_setup_PLANESURFACE, METH_O, NULL},
	 { "dwg_setup_POINTCLOUD", _wrap_dwg_setup_POINTCLOUD, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDEX", _wrap_dwg_setup_POINTCLOUDEX, METH_O, NULL},
	 { "dwg_setup_ACSH_BREP_CLASS", _wrap_dwg_setup_ACSH_BREP_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_CHAMFER_CLASS", _wrap_dwg_setup_ACSH_CHAMFER_CLASS, METH_O, NULL},
	 { "dwg_setup_ACSH_PYRAMID_CLASS", _wrap_dwg_setup_ACSH_PYRAMID_CLASS, METH_O, NULL},
	 { "dwg_setup_ALDIMOBJECTCONTEXTDATA", _wrap_dwg_setup_ALDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_ASSOC2DCONSTRAINTGROUP", _wrap_dwg_setup_ASSOC2DCONSTRAINTGROUP, METH_O, NULL},
	 { "dwg_setup_ASSOCACTION", _wrap_dwg_setup_ASSOCACTION, METH_O, NULL},
	 { "dwg_setup_ASSOCACTIONPARAM", _wrap_dwg_setup_ASSOCACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCARRAYACTIONBODY", _wrap_dwg_setup_ASSOCARRAYACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCASMBODYACTIONPARAM", _wrap_dwg_setup_ASSOCASMBODYACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCBLENDSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCBLENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCCOMPOUNDACTIONPARAM", _wrap_dwg_setup_ASSOCCOMPOUNDACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCDEPENDENCY", _wrap_dwg_setup_ASSOCDEPENDENCY, METH_O, NULL},
	 { "dwg_setup_ASSOCDIMDEPENDENCYBODY", _wrap_dwg_setup_ASSOCDIMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCEXTENDSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCEXTENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCEXTRUDEDSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCEXTRUDEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCFACEACTIONPARAM", _wrap_dwg_setup_ASSOCFACEACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCFILLETSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCFILLETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCLOFTEDSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCLOFTEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCNETWORKSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCNETWORKSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCOBJECTACTIONPARAM", _wrap_dwg_setup_ASSOCOBJECTACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCOFFSETSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCOFFSETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCOSNAPPOINTREFACTIONPARAM", _wrap_dwg_setup_ASSOCOSNAPPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCPATCHSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCPATCHSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCPATHACTIONPARAM", _wrap_dwg_setup_ASSOCPATHACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCPLANESURFACEACTIONBODY", _wrap_dwg_setup_ASSOCPLANESURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCPOINTREFACTIONPARAM", _wrap_dwg_setup_ASSOCPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_ASSOCREVOLVEDSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCREVOLVEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCTRIMSURFACEACTIONBODY", _wrap_dwg_setup_ASSOCTRIMSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_setup_ASSOCVALUEDEPENDENCY", _wrap_dwg_setup_ASSOCVALUEDEPENDENCY, METH_O, NULL},
	 { "dwg_setup_ASSOCVARIABLE", _wrap_dwg_setup_ASSOCVARIABLE, METH_O, NULL},
	 { "dwg_setup_ASSOCVERTEXACTIONPARAM", _wrap_dwg_setup_ASSOCVERTEXACTIONPARAM, METH_O, NULL},
	 { "dwg_setup_BLKREFOBJECTCONTEXTDATA", _wrap_dwg_setup_BLKREFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_BLOCKALIGNEDCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKALIGNEDCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKANGULARCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKANGULARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKARRAYACTION", _wrap_dwg_setup_BLOCKARRAYACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKDIAMETRICCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKDIAMETRICCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKHORIZONTALCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKHORIZONTALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKLINEARCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKLINEARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKLINEARPARAMETER", _wrap_dwg_setup_BLOCKLINEARPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKLOOKUPACTION", _wrap_dwg_setup_BLOCKLOOKUPACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKLOOKUPPARAMETER", _wrap_dwg_setup_BLOCKLOOKUPPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKPARAMDEPENDENCYBODY", _wrap_dwg_setup_BLOCKPARAMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_setup_BLOCKPOINTPARAMETER", _wrap_dwg_setup_BLOCKPOINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKPOLARGRIP", _wrap_dwg_setup_BLOCKPOLARGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKPOLARPARAMETER", _wrap_dwg_setup_BLOCKPOLARPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKPOLARSTRETCHACTION", _wrap_dwg_setup_BLOCKPOLARSTRETCHACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKRADIALCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKRADIALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKREPRESENTATION", _wrap_dwg_setup_BLOCKREPRESENTATION, METH_O, NULL},
	 { "dwg_setup_BLOCKROTATIONPARAMETER", _wrap_dwg_setup_BLOCKROTATIONPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKSTRETCHACTION", _wrap_dwg_setup_BLOCKSTRETCHACTION, METH_O, NULL},
	 { "dwg_setup_BLOCKUSERPARAMETER", _wrap_dwg_setup_BLOCKUSERPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKVERTICALCONSTRAINTPARAMETER", _wrap_dwg_setup_BLOCKVERTICALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKVISIBILITYPARAMETER", _wrap_dwg_setup_BLOCKVISIBILITYPARAMETER, METH_O, NULL},
	 { "dwg_setup_BLOCKXYGRIP", _wrap_dwg_setup_BLOCKXYGRIP, METH_O, NULL},
	 { "dwg_setup_BLOCKXYPARAMETER", _wrap_dwg_setup_BLOCKXYPARAMETER, METH_O, NULL},
	 { "dwg_setup_DATALINK", _wrap_dwg_setup_DATALINK, METH_O, NULL},
	 { "dwg_setup_DBCOLOR", _wrap_dwg_setup_DBCOLOR, METH_O, NULL},
	 { "dwg_setup_EVALUATION_GRAPH", _wrap_dwg_setup_EVALUATION_GRAPH, METH_O, NULL},
	 { "dwg_setup_FCFOBJECTCONTEXTDATA", _wrap_dwg_setup_FCFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_GRADIENT_BACKGROUND", _wrap_dwg_setup_GRADIENT_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_GROUND_PLANE_BACKGROUND", _wrap_dwg_setup_GROUND_PLANE_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_IBL_BACKGROUND", _wrap_dwg_setup_IBL_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_IMAGE_BACKGROUND", _wrap_dwg_setup_IMAGE_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_LEADEROBJECTCONTEXTDATA", _wrap_dwg_setup_LEADEROBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_LIGHTLIST", _wrap_dwg_setup_LIGHTLIST, METH_O, NULL},
	 { "dwg_setup_MATERIAL", _wrap_dwg_setup_MATERIAL, METH_O, NULL},
	 { "dwg_setup_MENTALRAYRENDERSETTINGS", _wrap_dwg_setup_MENTALRAYRENDERSETTINGS, METH_O, NULL},
	 { "dwg_setup_MLEADERSTYLE", _wrap_dwg_setup_MLEADERSTYLE, METH_O, NULL},
	 { "dwg_setup_MTEXTOBJECTCONTEXTDATA", _wrap_dwg_setup_MTEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_OBJECT_PTR", _wrap_dwg_setup_OBJECT_PTR, METH_O, NULL},
	 { "dwg_setup_PARTIAL_VIEWING_INDEX", _wrap_dwg_setup_PARTIAL_VIEWING_INDEX, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDCOLORMAP", _wrap_dwg_setup_POINTCLOUDCOLORMAP, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDDEF", _wrap_dwg_setup_POINTCLOUDDEF, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDDEFEX", _wrap_dwg_setup_POINTCLOUDDEFEX, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDDEF_REACTOR", _wrap_dwg_setup_POINTCLOUDDEF_REACTOR, METH_O, NULL},
	 { "dwg_setup_POINTCLOUDDEF_REACTOR_EX", _wrap_dwg_setup_POINTCLOUDDEF_REACTOR_EX, METH_O, NULL},
	 { "dwg_setup_PROXY_OBJECT", _wrap_dwg_setup_PROXY_OBJECT, METH_O, NULL},
	 { "dwg_setup_RAPIDRTRENDERSETTINGS", _wrap_dwg_setup_RAPIDRTRENDERSETTINGS, METH_O, NULL},
	 { "dwg_setup_RENDERENTRY", _wrap_dwg_setup_RENDERENTRY, METH_O, NULL},
	 { "dwg_setup_RENDERGLOBAL", _wrap_dwg_setup_RENDERGLOBAL, METH_O, NULL},
	 { "dwg_setup_RENDERSETTINGS", _wrap_dwg_setup_RENDERSETTINGS, METH_O, NULL},
	 { "dwg_setup_SECTION_SETTINGS", _wrap_dwg_setup_SECTION_SETTINGS, METH_O, NULL},
	 { "dwg_setup_SKYLIGHT_BACKGROUND", _wrap_dwg_setup_SKYLIGHT_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_SOLID_BACKGROUND", _wrap_dwg_setup_SOLID_BACKGROUND, METH_O, NULL},
	 { "dwg_setup_SPATIAL_INDEX", _wrap_dwg_setup_SPATIAL_INDEX, METH_O, NULL},
	 { "dwg_setup_TABLESTYLE", _wrap_dwg_setup_TABLESTYLE, METH_O, NULL},
	 { "dwg_setup_TEXTOBJECTCONTEXTDATA", _wrap_dwg_setup_TEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_setup_ASSOCARRAYMODIFYPARAMETERS", _wrap_dwg_setup_ASSOCARRAYMODIFYPARAMETERS, METH_O, NULL},
	 { "dwg_setup_ASSOCARRAYPATHPARAMETERS", _wrap_dwg_setup_ASSOCARRAYPATHPARAMETERS, METH_O, NULL},
	 { "dwg_setup_ASSOCARRAYPOLARPARAMETERS", _wrap_dwg_setup_ASSOCARRAYPOLARPARAMETERS, METH_O, NULL},
	 { "dwg_setup_ASSOCARRAYRECTANGULARPARAMETERS", _wrap_dwg_setup_ASSOCARRAYRECTANGULARPARAMETERS, METH_O, NULL},
	 { "Dwg_DYNAPI_field_name_get", _wrap_Dwg_DYNAPI_field_name_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_type_get", _wrap_Dwg_DYNAPI_field_type_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_size_get", _wrap_Dwg_DYNAPI_field_size_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_offset_get", _wrap_Dwg_DYNAPI_field_offset_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_is_indirect_get", _wrap_Dwg_DYNAPI_field_is_indirect_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_is_malloc_get", _wrap_Dwg_DYNAPI_field_is_malloc_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_is_string_get", _wrap_Dwg_DYNAPI_field_is_string_get, METH_O, NULL},
	 { "Dwg_DYNAPI_field_dxf_get", _wrap_Dwg_DYNAPI_field_dxf_get, METH_O, NULL},
	 { "new_Dwg_DYNAPI_field", _wrap_new_Dwg_DYNAPI_field, METH_NOARGS, NULL},
	 { "delete_Dwg_DYNAPI_field", _wrap_delete_Dwg_DYNAPI_field, METH_O, NULL},
	 { "Dwg_DYNAPI_field_swigregister", Dwg_DYNAPI_field_swigregister, METH_O, NULL},
	 { "Dwg_DYNAPI_field_swiginit", Dwg_DYNAPI_field_swiginit, METH_VARARGS, NULL},
	 { "is_dwg_entity", _wrap_is_dwg_entity, METH_O, NULL},
	 { "is_dwg_object", _wrap_is_dwg_object, METH_O, NULL},
	 { "dwg_dynapi_header_value", _wrap_dwg_dynapi_header_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_entity_value", _wrap_dwg_dynapi_entity_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_common_value", _wrap_dwg_dynapi_common_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_subclass_value", _wrap_dwg_dynapi_subclass_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_header_utf8text", _wrap_dwg_dynapi_header_utf8text, METH_VARARGS, NULL},
	 { "dwg_dynapi_entity_utf8text", _wrap_dwg_dynapi_entity_utf8text, METH_VARARGS, NULL},
	 { "dwg_dynapi_common_utf8text", _wrap_dwg_dynapi_common_utf8text, METH_VARARGS, NULL},
	 { "dwg_dynapi_header_set_value", _wrap_dwg_dynapi_header_set_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_entity_set_value", _wrap_dwg_dynapi_entity_set_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_common_set_value", _wrap_dwg_dynapi_common_set_value, METH_VARARGS, NULL},
	 { "dwg_dynapi_handle_name", _wrap_dwg_dynapi_handle_name, METH_VARARGS, NULL},
	 { "dwg_dynapi_header_field", _wrap_dwg_dynapi_header_field, METH_O, NULL},
	 { "dwg_dynapi_entity_field", _wrap_dwg_dynapi_entity_field, METH_VARARGS, NULL},
	 { "dwg_dynapi_subclass_field", _wrap_dwg_dynapi_subclass_field, METH_VARARGS, NULL},
	 { "dwg_dynapi_common_entity_field", _wrap_dwg_dynapi_common_entity_field, METH_O, NULL},
	 { "dwg_dynapi_common_object_field", _wrap_dwg_dynapi_common_object_field, METH_O, NULL},
	 { "dwg_dynapi_entity_fields", _wrap_dwg_dynapi_entity_fields, METH_O, NULL},
	 { "dwg_dynapi_common_entity_fields", _wrap_dwg_dynapi_common_entity_fields, METH_NOARGS, NULL},
	 { "dwg_dynapi_common_object_fields", _wrap_dwg_dynapi_common_object_fields, METH_NOARGS, NULL},
	 { "dwg_dynapi_subclass_fields", _wrap_dwg_dynapi_subclass_fields, METH_O, NULL},
	 { "dwg_dynapi_fields_size", _wrap_dwg_dynapi_fields_size, METH_O, NULL},
	 { "dwg_object_tablectrl_get_entries", _wrap_dwg_object_tablectrl_get_entries, METH_VARARGS, NULL},
	 { "dwg_ref_get_table_name", _wrap_dwg_ref_get_table_name, METH_VARARGS, NULL},
	 { "dwg_ent_get_layer_name", _wrap_dwg_ent_get_layer_name, METH_VARARGS, NULL},
	 { "dwg_obj_layer_get_name", _wrap_dwg_obj_layer_get_name, METH_VARARGS, NULL},
	 { "dwg_obj_table_get_name", _wrap_dwg_obj_table_get_name, METH_VARARGS, NULL},
	 { "dwg_ent_to_object", _wrap_dwg_ent_to_object, METH_VARARGS, NULL},
	 { "dwg_object_to_object", _wrap_dwg_object_to_object, METH_VARARGS, NULL},
	 { "dwg_obj_obj_to_object", _wrap_dwg_obj_obj_to_object, METH_VARARGS, NULL},
	 { "dwg_object_to_entity", _wrap_dwg_object_to_entity, METH_VARARGS, NULL},
	 { "dwg_object_get_type", _wrap_dwg_object_get_type, METH_O, NULL},
	 { "dwg_object_get_fixedtype", _wrap_dwg_object_get_fixedtype, METH_O, NULL},
	 { "dwg_object_get_dxfname", _wrap_dwg_object_get_dxfname, METH_O, NULL},
	 { "dwg_ref_get_absref", _wrap_dwg_ref_get_absref, METH_VARARGS, NULL},
	 { "dwg_ref_get_object", _wrap_dwg_ref_get_object, METH_VARARGS, NULL},
	 { "dwg_absref_get_object", _wrap_dwg_absref_get_object, METH_VARARGS, NULL},
	 { "dwg_get_num_classes", _wrap_dwg_get_num_classes, METH_O, NULL},
	 { "dwg_get_class", _wrap_dwg_get_class, METH_VARARGS, NULL},
	 { "dwg_get_object", _wrap_dwg_get_object, METH_VARARGS, NULL},
	 { "dwg_obj_generic_to_object", _wrap_dwg_obj_generic_to_object, METH_VARARGS, NULL},
	 { "dwg_obj_generic_parent", _wrap_dwg_obj_generic_parent, METH_VARARGS, NULL},
	 { "dwg_object_to_DIMENSION", _wrap_dwg_object_to_DIMENSION, METH_O, NULL},
	 { "dwg_getall__3DFACE", _wrap_dwg_getall__3DFACE, METH_O, NULL},
	 { "dwg_getall__3DLINE", _wrap_dwg_getall__3DLINE, METH_O, NULL},
	 { "dwg_getall__3DSOLID", _wrap_dwg_getall__3DSOLID, METH_O, NULL},
	 { "dwg_getall_ARC", _wrap_dwg_getall_ARC, METH_O, NULL},
	 { "dwg_getall_ATTDEF", _wrap_dwg_getall_ATTDEF, METH_O, NULL},
	 { "dwg_getall_ATTRIB", _wrap_dwg_getall_ATTRIB, METH_O, NULL},
	 { "dwg_getall_BLOCK", _wrap_dwg_getall_BLOCK, METH_O, NULL},
	 { "dwg_getall_BODY", _wrap_dwg_getall_BODY, METH_O, NULL},
	 { "dwg_getall_CAMERA", _wrap_dwg_getall_CAMERA, METH_O, NULL},
	 { "dwg_getall_CIRCLE", _wrap_dwg_getall_CIRCLE, METH_O, NULL},
	 { "dwg_getall_DGNUNDERLAY", _wrap_dwg_getall_DGNUNDERLAY, METH_O, NULL},
	 { "dwg_getall_DIMENSION_ALIGNED", _wrap_dwg_getall_DIMENSION_ALIGNED, METH_O, NULL},
	 { "dwg_getall_DIMENSION_ANG2LN", _wrap_dwg_getall_DIMENSION_ANG2LN, METH_O, NULL},
	 { "dwg_getall_DIMENSION_ANG3PT", _wrap_dwg_getall_DIMENSION_ANG3PT, METH_O, NULL},
	 { "dwg_getall_DIMENSION_DIAMETER", _wrap_dwg_getall_DIMENSION_DIAMETER, METH_O, NULL},
	 { "dwg_getall_DIMENSION_LINEAR", _wrap_dwg_getall_DIMENSION_LINEAR, METH_O, NULL},
	 { "dwg_getall_DIMENSION_ORDINATE", _wrap_dwg_getall_DIMENSION_ORDINATE, METH_O, NULL},
	 { "dwg_getall_DIMENSION_RADIUS", _wrap_dwg_getall_DIMENSION_RADIUS, METH_O, NULL},
	 { "dwg_getall_DWFUNDERLAY", _wrap_dwg_getall_DWFUNDERLAY, METH_O, NULL},
	 { "dwg_getall_ELLIPSE", _wrap_dwg_getall_ELLIPSE, METH_O, NULL},
	 { "dwg_getall_ENDBLK", _wrap_dwg_getall_ENDBLK, METH_O, NULL},
	 { "dwg_getall_ENDREP", _wrap_dwg_getall_ENDREP, METH_O, NULL},
	 { "dwg_getall_HATCH", _wrap_dwg_getall_HATCH, METH_O, NULL},
	 { "dwg_getall_IMAGE", _wrap_dwg_getall_IMAGE, METH_O, NULL},
	 { "dwg_getall_INSERT", _wrap_dwg_getall_INSERT, METH_O, NULL},
	 { "dwg_getall_JUMP", _wrap_dwg_getall_JUMP, METH_O, NULL},
	 { "dwg_getall_LEADER", _wrap_dwg_getall_LEADER, METH_O, NULL},
	 { "dwg_getall_LIGHT", _wrap_dwg_getall_LIGHT, METH_O, NULL},
	 { "dwg_getall_LINE", _wrap_dwg_getall_LINE, METH_O, NULL},
	 { "dwg_getall_LOAD", _wrap_dwg_getall_LOAD, METH_O, NULL},
	 { "dwg_getall_LWPOLYLINE", _wrap_dwg_getall_LWPOLYLINE, METH_O, NULL},
	 { "dwg_getall_MESH", _wrap_dwg_getall_MESH, METH_O, NULL},
	 { "dwg_getall_MINSERT", _wrap_dwg_getall_MINSERT, METH_O, NULL},
	 { "dwg_getall_MLINE", _wrap_dwg_getall_MLINE, METH_O, NULL},
	 { "dwg_getall_MTEXT", _wrap_dwg_getall_MTEXT, METH_O, NULL},
	 { "dwg_getall_MULTILEADER", _wrap_dwg_getall_MULTILEADER, METH_O, NULL},
	 { "dwg_getall_OLE2FRAME", _wrap_dwg_getall_OLE2FRAME, METH_O, NULL},
	 { "dwg_getall_OLEFRAME", _wrap_dwg_getall_OLEFRAME, METH_O, NULL},
	 { "dwg_getall_PDFUNDERLAY", _wrap_dwg_getall_PDFUNDERLAY, METH_O, NULL},
	 { "dwg_getall_POINT", _wrap_dwg_getall_POINT, METH_O, NULL},
	 { "dwg_getall_POLYLINE_2D", _wrap_dwg_getall_POLYLINE_2D, METH_O, NULL},
	 { "dwg_getall_POLYLINE_3D", _wrap_dwg_getall_POLYLINE_3D, METH_O, NULL},
	 { "dwg_getall_POLYLINE_MESH", _wrap_dwg_getall_POLYLINE_MESH, METH_O, NULL},
	 { "dwg_getall_POLYLINE_PFACE", _wrap_dwg_getall_POLYLINE_PFACE, METH_O, NULL},
	 { "dwg_getall_PROXY_ENTITY", _wrap_dwg_getall_PROXY_ENTITY, METH_O, NULL},
	 { "dwg_getall_RAY", _wrap_dwg_getall_RAY, METH_O, NULL},
	 { "dwg_getall_REGION", _wrap_dwg_getall_REGION, METH_O, NULL},
	 { "dwg_getall_REPEAT", _wrap_dwg_getall_REPEAT, METH_O, NULL},
	 { "dwg_getall_SECTIONOBJECT", _wrap_dwg_getall_SECTIONOBJECT, METH_O, NULL},
	 { "dwg_getall_SEQEND", _wrap_dwg_getall_SEQEND, METH_O, NULL},
	 { "dwg_getall_SHAPE", _wrap_dwg_getall_SHAPE, METH_O, NULL},
	 { "dwg_getall_SOLID", _wrap_dwg_getall_SOLID, METH_O, NULL},
	 { "dwg_getall_SPLINE", _wrap_dwg_getall_SPLINE, METH_O, NULL},
	 { "dwg_getall_TEXT", _wrap_dwg_getall_TEXT, METH_O, NULL},
	 { "dwg_getall_TOLERANCE", _wrap_dwg_getall_TOLERANCE, METH_O, NULL},
	 { "dwg_getall_TRACE", _wrap_dwg_getall_TRACE, METH_O, NULL},
	 { "dwg_getall_UNKNOWN_ENT", _wrap_dwg_getall_UNKNOWN_ENT, METH_O, NULL},
	 { "dwg_getall_VERTEX_2D", _wrap_dwg_getall_VERTEX_2D, METH_O, NULL},
	 { "dwg_getall_VERTEX_3D", _wrap_dwg_getall_VERTEX_3D, METH_O, NULL},
	 { "dwg_getall_VERTEX_MESH", _wrap_dwg_getall_VERTEX_MESH, METH_O, NULL},
	 { "dwg_getall_VERTEX_PFACE", _wrap_dwg_getall_VERTEX_PFACE, METH_O, NULL},
	 { "dwg_getall_VERTEX_PFACE_FACE", _wrap_dwg_getall_VERTEX_PFACE_FACE, METH_O, NULL},
	 { "dwg_getall_VIEWPORT", _wrap_dwg_getall_VIEWPORT, METH_O, NULL},
	 { "dwg_getall_WIPEOUT", _wrap_dwg_getall_WIPEOUT, METH_O, NULL},
	 { "dwg_getall_XLINE", _wrap_dwg_getall_XLINE, METH_O, NULL},
	 { "dwg_getall_ARC_DIMENSION", _wrap_dwg_getall_ARC_DIMENSION, METH_O, NULL},
	 { "dwg_getall_HELIX", _wrap_dwg_getall_HELIX, METH_O, NULL},
	 { "dwg_getall_LARGE_RADIAL_DIMENSION", _wrap_dwg_getall_LARGE_RADIAL_DIMENSION, METH_O, NULL},
	 { "dwg_getall_LAYOUTPRINTCONFIG", _wrap_dwg_getall_LAYOUTPRINTCONFIG, METH_O, NULL},
	 { "dwg_getall_PLANESURFACE", _wrap_dwg_getall_PLANESURFACE, METH_O, NULL},
	 { "dwg_getall_POINTCLOUD", _wrap_dwg_getall_POINTCLOUD, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDEX", _wrap_dwg_getall_POINTCLOUDEX, METH_O, NULL},
	 { "dwg_getall_ACSH_BOOLEAN_CLASS", _wrap_dwg_getall_ACSH_BOOLEAN_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_BOX_CLASS", _wrap_dwg_getall_ACSH_BOX_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_CONE_CLASS", _wrap_dwg_getall_ACSH_CONE_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_CYLINDER_CLASS", _wrap_dwg_getall_ACSH_CYLINDER_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_FILLET_CLASS", _wrap_dwg_getall_ACSH_FILLET_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_HISTORY_CLASS", _wrap_dwg_getall_ACSH_HISTORY_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_SPHERE_CLASS", _wrap_dwg_getall_ACSH_SPHERE_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_TORUS_CLASS", _wrap_dwg_getall_ACSH_TORUS_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_WEDGE_CLASS", _wrap_dwg_getall_ACSH_WEDGE_CLASS, METH_O, NULL},
	 { "dwg_getall_APPID", _wrap_dwg_getall_APPID, METH_O, NULL},
	 { "dwg_getall_APPID_CONTROL", _wrap_dwg_getall_APPID_CONTROL, METH_O, NULL},
	 { "dwg_getall_ASSOCGEOMDEPENDENCY", _wrap_dwg_getall_ASSOCGEOMDEPENDENCY, METH_O, NULL},
	 { "dwg_getall_ASSOCNETWORK", _wrap_dwg_getall_ASSOCNETWORK, METH_O, NULL},
	 { "dwg_getall_BLOCKALIGNMENTGRIP", _wrap_dwg_getall_BLOCKALIGNMENTGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKALIGNMENTPARAMETER", _wrap_dwg_getall_BLOCKALIGNMENTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKBASEPOINTPARAMETER", _wrap_dwg_getall_BLOCKBASEPOINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKFLIPACTION", _wrap_dwg_getall_BLOCKFLIPACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKFLIPGRIP", _wrap_dwg_getall_BLOCKFLIPGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKFLIPPARAMETER", _wrap_dwg_getall_BLOCKFLIPPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKGRIPLOCATIONCOMPONENT", _wrap_dwg_getall_BLOCKGRIPLOCATIONCOMPONENT, METH_O, NULL},
	 { "dwg_getall_BLOCKLINEARGRIP", _wrap_dwg_getall_BLOCKLINEARGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKLOOKUPGRIP", _wrap_dwg_getall_BLOCKLOOKUPGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKMOVEACTION", _wrap_dwg_getall_BLOCKMOVEACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKROTATEACTION", _wrap_dwg_getall_BLOCKROTATEACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKROTATIONGRIP", _wrap_dwg_getall_BLOCKROTATIONGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKSCALEACTION", _wrap_dwg_getall_BLOCKSCALEACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKVISIBILITYGRIP", _wrap_dwg_getall_BLOCKVISIBILITYGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCK_CONTROL", _wrap_dwg_getall_BLOCK_CONTROL, METH_O, NULL},
	 { "dwg_getall_BLOCK_HEADER", _wrap_dwg_getall_BLOCK_HEADER, METH_O, NULL},
	 { "dwg_getall_CELLSTYLEMAP", _wrap_dwg_getall_CELLSTYLEMAP, METH_O, NULL},
	 { "dwg_getall_DETAILVIEWSTYLE", _wrap_dwg_getall_DETAILVIEWSTYLE, METH_O, NULL},
	 { "dwg_getall_DICTIONARY", _wrap_dwg_getall_DICTIONARY, METH_O, NULL},
	 { "dwg_getall_DICTIONARYVAR", _wrap_dwg_getall_DICTIONARYVAR, METH_O, NULL},
	 { "dwg_getall_DICTIONARYWDFLT", _wrap_dwg_getall_DICTIONARYWDFLT, METH_O, NULL},
	 { "dwg_getall_DIMSTYLE", _wrap_dwg_getall_DIMSTYLE, METH_O, NULL},
	 { "dwg_getall_DIMSTYLE_CONTROL", _wrap_dwg_getall_DIMSTYLE_CONTROL, METH_O, NULL},
	 { "dwg_getall_DUMMY", _wrap_dwg_getall_DUMMY, METH_O, NULL},
	 { "dwg_getall_DYNAMICBLOCKPURGEPREVENTER", _wrap_dwg_getall_DYNAMICBLOCKPURGEPREVENTER, METH_O, NULL},
	 { "dwg_getall_FIELD", _wrap_dwg_getall_FIELD, METH_O, NULL},
	 { "dwg_getall_FIELDLIST", _wrap_dwg_getall_FIELDLIST, METH_O, NULL},
	 { "dwg_getall_GEODATA", _wrap_dwg_getall_GEODATA, METH_O, NULL},
	 { "dwg_getall_GROUP", _wrap_dwg_getall_GROUP, METH_O, NULL},
	 { "dwg_getall_IDBUFFER", _wrap_dwg_getall_IDBUFFER, METH_O, NULL},
	 { "dwg_getall_IMAGEDEF", _wrap_dwg_getall_IMAGEDEF, METH_O, NULL},
	 { "dwg_getall_IMAGEDEF_REACTOR", _wrap_dwg_getall_IMAGEDEF_REACTOR, METH_O, NULL},
	 { "dwg_getall_INDEX", _wrap_dwg_getall_INDEX, METH_O, NULL},
	 { "dwg_getall_LAYER", _wrap_dwg_getall_LAYER, METH_O, NULL},
	 { "dwg_getall_LAYERFILTER", _wrap_dwg_getall_LAYERFILTER, METH_O, NULL},
	 { "dwg_getall_LAYER_CONTROL", _wrap_dwg_getall_LAYER_CONTROL, METH_O, NULL},
	 { "dwg_getall_LAYER_INDEX", _wrap_dwg_getall_LAYER_INDEX, METH_O, NULL},
	 { "dwg_getall_LAYOUT", _wrap_dwg_getall_LAYOUT, METH_O, NULL},
	 { "dwg_getall_LONG_TRANSACTION", _wrap_dwg_getall_LONG_TRANSACTION, METH_O, NULL},
	 { "dwg_getall_LTYPE", _wrap_dwg_getall_LTYPE, METH_O, NULL},
	 { "dwg_getall_LTYPE_CONTROL", _wrap_dwg_getall_LTYPE_CONTROL, METH_O, NULL},
	 { "dwg_getall_MLINESTYLE", _wrap_dwg_getall_MLINESTYLE, METH_O, NULL},
	 { "dwg_getall_PLACEHOLDER", _wrap_dwg_getall_PLACEHOLDER, METH_O, NULL},
	 { "dwg_getall_PLOTSETTINGS", _wrap_dwg_getall_PLOTSETTINGS, METH_O, NULL},
	 { "dwg_getall_RASTERVARIABLES", _wrap_dwg_getall_RASTERVARIABLES, METH_O, NULL},
	 { "dwg_getall_RENDERENVIRONMENT", _wrap_dwg_getall_RENDERENVIRONMENT, METH_O, NULL},
	 { "dwg_getall_SCALE", _wrap_dwg_getall_SCALE, METH_O, NULL},
	 { "dwg_getall_SECTIONVIEWSTYLE", _wrap_dwg_getall_SECTIONVIEWSTYLE, METH_O, NULL},
	 { "dwg_getall_SECTION_MANAGER", _wrap_dwg_getall_SECTION_MANAGER, METH_O, NULL},
	 { "dwg_getall_SORTENTSTABLE", _wrap_dwg_getall_SORTENTSTABLE, METH_O, NULL},
	 { "dwg_getall_SPATIAL_FILTER", _wrap_dwg_getall_SPATIAL_FILTER, METH_O, NULL},
	 { "dwg_getall_STYLE", _wrap_dwg_getall_STYLE, METH_O, NULL},
	 { "dwg_getall_STYLE_CONTROL", _wrap_dwg_getall_STYLE_CONTROL, METH_O, NULL},
	 { "dwg_getall_SUN", _wrap_dwg_getall_SUN, METH_O, NULL},
	 { "dwg_getall_TABLEGEOMETRY", _wrap_dwg_getall_TABLEGEOMETRY, METH_O, NULL},
	 { "dwg_getall_UCS", _wrap_dwg_getall_UCS, METH_O, NULL},
	 { "dwg_getall_UCS_CONTROL", _wrap_dwg_getall_UCS_CONTROL, METH_O, NULL},
	 { "dwg_getall_UNKNOWN_OBJ", _wrap_dwg_getall_UNKNOWN_OBJ, METH_O, NULL},
	 { "dwg_getall_VBA_PROJECT", _wrap_dwg_getall_VBA_PROJECT, METH_O, NULL},
	 { "dwg_getall_VIEW", _wrap_dwg_getall_VIEW, METH_O, NULL},
	 { "dwg_getall_VIEW_CONTROL", _wrap_dwg_getall_VIEW_CONTROL, METH_O, NULL},
	 { "dwg_getall_VISUALSTYLE", _wrap_dwg_getall_VISUALSTYLE, METH_O, NULL},
	 { "dwg_getall_VPORT", _wrap_dwg_getall_VPORT, METH_O, NULL},
	 { "dwg_getall_VPORT_CONTROL", _wrap_dwg_getall_VPORT_CONTROL, METH_O, NULL},
	 { "dwg_getall_VX_CONTROL", _wrap_dwg_getall_VX_CONTROL, METH_O, NULL},
	 { "dwg_getall_VX_TABLE_RECORD", _wrap_dwg_getall_VX_TABLE_RECORD, METH_O, NULL},
	 { "dwg_getall_WIPEOUTVARIABLES", _wrap_dwg_getall_WIPEOUTVARIABLES, METH_O, NULL},
	 { "dwg_getall_XRECORD", _wrap_dwg_getall_XRECORD, METH_O, NULL},
	 { "dwg_getall_PDFDEFINITION", _wrap_dwg_getall_PDFDEFINITION, METH_O, NULL},
	 { "dwg_getall_DGNDEFINITION", _wrap_dwg_getall_DGNDEFINITION, METH_O, NULL},
	 { "dwg_getall_DWFDEFINITION", _wrap_dwg_getall_DWFDEFINITION, METH_O, NULL},
	 { "dwg_getall_ACSH_BREP_CLASS", _wrap_dwg_getall_ACSH_BREP_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_CHAMFER_CLASS", _wrap_dwg_getall_ACSH_CHAMFER_CLASS, METH_O, NULL},
	 { "dwg_getall_ACSH_PYRAMID_CLASS", _wrap_dwg_getall_ACSH_PYRAMID_CLASS, METH_O, NULL},
	 { "dwg_getall_ALDIMOBJECTCONTEXTDATA", _wrap_dwg_getall_ALDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_ASSOC2DCONSTRAINTGROUP", _wrap_dwg_getall_ASSOC2DCONSTRAINTGROUP, METH_O, NULL},
	 { "dwg_getall_ASSOCACTION", _wrap_dwg_getall_ASSOCACTION, METH_O, NULL},
	 { "dwg_getall_ASSOCACTIONPARAM", _wrap_dwg_getall_ASSOCACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCARRAYACTIONBODY", _wrap_dwg_getall_ASSOCARRAYACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCASMBODYACTIONPARAM", _wrap_dwg_getall_ASSOCASMBODYACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCBLENDSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCBLENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCCOMPOUNDACTIONPARAM", _wrap_dwg_getall_ASSOCCOMPOUNDACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCDEPENDENCY", _wrap_dwg_getall_ASSOCDEPENDENCY, METH_O, NULL},
	 { "dwg_getall_ASSOCDIMDEPENDENCYBODY", _wrap_dwg_getall_ASSOCDIMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCEXTENDSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCEXTENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCEXTRUDEDSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCEXTRUDEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCFACEACTIONPARAM", _wrap_dwg_getall_ASSOCFACEACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCFILLETSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCFILLETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCLOFTEDSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCLOFTEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCNETWORKSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCNETWORKSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCOBJECTACTIONPARAM", _wrap_dwg_getall_ASSOCOBJECTACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCOFFSETSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCOFFSETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCOSNAPPOINTREFACTIONPARAM", _wrap_dwg_getall_ASSOCOSNAPPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCPATCHSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCPATCHSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCPATHACTIONPARAM", _wrap_dwg_getall_ASSOCPATHACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCPLANESURFACEACTIONBODY", _wrap_dwg_getall_ASSOCPLANESURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCPOINTREFACTIONPARAM", _wrap_dwg_getall_ASSOCPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_ASSOCREVOLVEDSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCREVOLVEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCTRIMSURFACEACTIONBODY", _wrap_dwg_getall_ASSOCTRIMSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_getall_ASSOCVALUEDEPENDENCY", _wrap_dwg_getall_ASSOCVALUEDEPENDENCY, METH_O, NULL},
	 { "dwg_getall_ASSOCVARIABLE", _wrap_dwg_getall_ASSOCVARIABLE, METH_O, NULL},
	 { "dwg_getall_ASSOCVERTEXACTIONPARAM", _wrap_dwg_getall_ASSOCVERTEXACTIONPARAM, METH_O, NULL},
	 { "dwg_getall_BLKREFOBJECTCONTEXTDATA", _wrap_dwg_getall_BLKREFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_BLOCKALIGNEDCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKALIGNEDCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKANGULARCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKANGULARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKARRAYACTION", _wrap_dwg_getall_BLOCKARRAYACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKDIAMETRICCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKDIAMETRICCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKHORIZONTALCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKHORIZONTALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKLINEARCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKLINEARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKLINEARPARAMETER", _wrap_dwg_getall_BLOCKLINEARPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKLOOKUPACTION", _wrap_dwg_getall_BLOCKLOOKUPACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKLOOKUPPARAMETER", _wrap_dwg_getall_BLOCKLOOKUPPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKPARAMDEPENDENCYBODY", _wrap_dwg_getall_BLOCKPARAMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_getall_BLOCKPOINTPARAMETER", _wrap_dwg_getall_BLOCKPOINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKPOLARGRIP", _wrap_dwg_getall_BLOCKPOLARGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKPOLARPARAMETER", _wrap_dwg_getall_BLOCKPOLARPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKPOLARSTRETCHACTION", _wrap_dwg_getall_BLOCKPOLARSTRETCHACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKRADIALCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKRADIALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKREPRESENTATION", _wrap_dwg_getall_BLOCKREPRESENTATION, METH_O, NULL},
	 { "dwg_getall_BLOCKROTATIONPARAMETER", _wrap_dwg_getall_BLOCKROTATIONPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKSTRETCHACTION", _wrap_dwg_getall_BLOCKSTRETCHACTION, METH_O, NULL},
	 { "dwg_getall_BLOCKUSERPARAMETER", _wrap_dwg_getall_BLOCKUSERPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKVERTICALCONSTRAINTPARAMETER", _wrap_dwg_getall_BLOCKVERTICALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKVISIBILITYPARAMETER", _wrap_dwg_getall_BLOCKVISIBILITYPARAMETER, METH_O, NULL},
	 { "dwg_getall_BLOCKXYGRIP", _wrap_dwg_getall_BLOCKXYGRIP, METH_O, NULL},
	 { "dwg_getall_BLOCKXYPARAMETER", _wrap_dwg_getall_BLOCKXYPARAMETER, METH_O, NULL},
	 { "dwg_getall_DATALINK", _wrap_dwg_getall_DATALINK, METH_O, NULL},
	 { "dwg_getall_DBCOLOR", _wrap_dwg_getall_DBCOLOR, METH_O, NULL},
	 { "dwg_getall_EVALUATION_GRAPH", _wrap_dwg_getall_EVALUATION_GRAPH, METH_O, NULL},
	 { "dwg_getall_FCFOBJECTCONTEXTDATA", _wrap_dwg_getall_FCFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_GRADIENT_BACKGROUND", _wrap_dwg_getall_GRADIENT_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_GROUND_PLANE_BACKGROUND", _wrap_dwg_getall_GROUND_PLANE_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_IBL_BACKGROUND", _wrap_dwg_getall_IBL_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_IMAGE_BACKGROUND", _wrap_dwg_getall_IMAGE_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_LEADEROBJECTCONTEXTDATA", _wrap_dwg_getall_LEADEROBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_LIGHTLIST", _wrap_dwg_getall_LIGHTLIST, METH_O, NULL},
	 { "dwg_getall_MATERIAL", _wrap_dwg_getall_MATERIAL, METH_O, NULL},
	 { "dwg_getall_MENTALRAYRENDERSETTINGS", _wrap_dwg_getall_MENTALRAYRENDERSETTINGS, METH_O, NULL},
	 { "dwg_getall_MLEADERSTYLE", _wrap_dwg_getall_MLEADERSTYLE, METH_O, NULL},
	 { "dwg_getall_MTEXTOBJECTCONTEXTDATA", _wrap_dwg_getall_MTEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_OBJECT_PTR", _wrap_dwg_getall_OBJECT_PTR, METH_O, NULL},
	 { "dwg_getall_PARTIAL_VIEWING_INDEX", _wrap_dwg_getall_PARTIAL_VIEWING_INDEX, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDCOLORMAP", _wrap_dwg_getall_POINTCLOUDCOLORMAP, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDDEF", _wrap_dwg_getall_POINTCLOUDDEF, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDDEFEX", _wrap_dwg_getall_POINTCLOUDDEFEX, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDDEF_REACTOR", _wrap_dwg_getall_POINTCLOUDDEF_REACTOR, METH_O, NULL},
	 { "dwg_getall_POINTCLOUDDEF_REACTOR_EX", _wrap_dwg_getall_POINTCLOUDDEF_REACTOR_EX, METH_O, NULL},
	 { "dwg_getall_PROXY_OBJECT", _wrap_dwg_getall_PROXY_OBJECT, METH_O, NULL},
	 { "dwg_getall_RAPIDRTRENDERSETTINGS", _wrap_dwg_getall_RAPIDRTRENDERSETTINGS, METH_O, NULL},
	 { "dwg_getall_RENDERENTRY", _wrap_dwg_getall_RENDERENTRY, METH_O, NULL},
	 { "dwg_getall_RENDERGLOBAL", _wrap_dwg_getall_RENDERGLOBAL, METH_O, NULL},
	 { "dwg_getall_RENDERSETTINGS", _wrap_dwg_getall_RENDERSETTINGS, METH_O, NULL},
	 { "dwg_getall_SECTION_SETTINGS", _wrap_dwg_getall_SECTION_SETTINGS, METH_O, NULL},
	 { "dwg_getall_SKYLIGHT_BACKGROUND", _wrap_dwg_getall_SKYLIGHT_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_SOLID_BACKGROUND", _wrap_dwg_getall_SOLID_BACKGROUND, METH_O, NULL},
	 { "dwg_getall_SPATIAL_INDEX", _wrap_dwg_getall_SPATIAL_INDEX, METH_O, NULL},
	 { "dwg_getall_TABLESTYLE", _wrap_dwg_getall_TABLESTYLE, METH_O, NULL},
	 { "dwg_getall_TEXTOBJECTCONTEXTDATA", _wrap_dwg_getall_TEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_getall_ASSOCARRAYMODIFYPARAMETERS", _wrap_dwg_getall_ASSOCARRAYMODIFYPARAMETERS, METH_O, NULL},
	 { "dwg_getall_ASSOCARRAYPATHPARAMETERS", _wrap_dwg_getall_ASSOCARRAYPATHPARAMETERS, METH_O, NULL},
	 { "dwg_getall_ASSOCARRAYPOLARPARAMETERS", _wrap_dwg_getall_ASSOCARRAYPOLARPARAMETERS, METH_O, NULL},
	 { "dwg_getall_ASSOCARRAYRECTANGULARPARAMETERS", _wrap_dwg_getall_ASSOCARRAYRECTANGULARPARAMETERS, METH_O, NULL},
	 { "dwg_object_to__3DFACE", _wrap_dwg_object_to__3DFACE, METH_O, NULL},
	 { "dwg_object_to__3DLINE", _wrap_dwg_object_to__3DLINE, METH_O, NULL},
	 { "dwg_object_to__3DSOLID", _wrap_dwg_object_to__3DSOLID, METH_O, NULL},
	 { "dwg_object_to_ARC", _wrap_dwg_object_to_ARC, METH_O, NULL},
	 { "dwg_object_to_ATTDEF", _wrap_dwg_object_to_ATTDEF, METH_O, NULL},
	 { "dwg_object_to_ATTRIB", _wrap_dwg_object_to_ATTRIB, METH_O, NULL},
	 { "dwg_object_to_BLOCK", _wrap_dwg_object_to_BLOCK, METH_O, NULL},
	 { "dwg_object_to_BODY", _wrap_dwg_object_to_BODY, METH_O, NULL},
	 { "dwg_object_to_CAMERA", _wrap_dwg_object_to_CAMERA, METH_O, NULL},
	 { "dwg_object_to_CIRCLE", _wrap_dwg_object_to_CIRCLE, METH_O, NULL},
	 { "dwg_object_to_DGNUNDERLAY", _wrap_dwg_object_to_DGNUNDERLAY, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_ALIGNED", _wrap_dwg_object_to_DIMENSION_ALIGNED, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_ANG2LN", _wrap_dwg_object_to_DIMENSION_ANG2LN, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_ANG3PT", _wrap_dwg_object_to_DIMENSION_ANG3PT, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_DIAMETER", _wrap_dwg_object_to_DIMENSION_DIAMETER, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_LINEAR", _wrap_dwg_object_to_DIMENSION_LINEAR, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_ORDINATE", _wrap_dwg_object_to_DIMENSION_ORDINATE, METH_O, NULL},
	 { "dwg_object_to_DIMENSION_RADIUS", _wrap_dwg_object_to_DIMENSION_RADIUS, METH_O, NULL},
	 { "dwg_object_to_DWFUNDERLAY", _wrap_dwg_object_to_DWFUNDERLAY, METH_O, NULL},
	 { "dwg_object_to_ELLIPSE", _wrap_dwg_object_to_ELLIPSE, METH_O, NULL},
	 { "dwg_object_to_ENDBLK", _wrap_dwg_object_to_ENDBLK, METH_O, NULL},
	 { "dwg_object_to_ENDREP", _wrap_dwg_object_to_ENDREP, METH_O, NULL},
	 { "dwg_object_to_HATCH", _wrap_dwg_object_to_HATCH, METH_O, NULL},
	 { "dwg_object_to_IMAGE", _wrap_dwg_object_to_IMAGE, METH_O, NULL},
	 { "dwg_object_to_INSERT", _wrap_dwg_object_to_INSERT, METH_O, NULL},
	 { "dwg_object_to_JUMP", _wrap_dwg_object_to_JUMP, METH_O, NULL},
	 { "dwg_object_to_LEADER", _wrap_dwg_object_to_LEADER, METH_O, NULL},
	 { "dwg_object_to_LIGHT", _wrap_dwg_object_to_LIGHT, METH_O, NULL},
	 { "dwg_object_to_LINE", _wrap_dwg_object_to_LINE, METH_O, NULL},
	 { "dwg_object_to_LOAD", _wrap_dwg_object_to_LOAD, METH_O, NULL},
	 { "dwg_object_to_LWPOLYLINE", _wrap_dwg_object_to_LWPOLYLINE, METH_O, NULL},
	 { "dwg_object_to_MESH", _wrap_dwg_object_to_MESH, METH_O, NULL},
	 { "dwg_object_to_MINSERT", _wrap_dwg_object_to_MINSERT, METH_O, NULL},
	 { "dwg_object_to_MLINE", _wrap_dwg_object_to_MLINE, METH_O, NULL},
	 { "dwg_object_to_MTEXT", _wrap_dwg_object_to_MTEXT, METH_O, NULL},
	 { "dwg_object_to_MULTILEADER", _wrap_dwg_object_to_MULTILEADER, METH_O, NULL},
	 { "dwg_object_to_OLE2FRAME", _wrap_dwg_object_to_OLE2FRAME, METH_O, NULL},
	 { "dwg_object_to_OLEFRAME", _wrap_dwg_object_to_OLEFRAME, METH_O, NULL},
	 { "dwg_object_to_PDFUNDERLAY", _wrap_dwg_object_to_PDFUNDERLAY, METH_O, NULL},
	 { "dwg_object_to_POINT", _wrap_dwg_object_to_POINT, METH_O, NULL},
	 { "dwg_object_to_POLYLINE_2D", _wrap_dwg_object_to_POLYLINE_2D, METH_O, NULL},
	 { "dwg_object_to_POLYLINE_3D", _wrap_dwg_object_to_POLYLINE_3D, METH_O, NULL},
	 { "dwg_object_to_POLYLINE_MESH", _wrap_dwg_object_to_POLYLINE_MESH, METH_O, NULL},
	 { "dwg_object_to_POLYLINE_PFACE", _wrap_dwg_object_to_POLYLINE_PFACE, METH_O, NULL},
	 { "dwg_object_to_PROXY_ENTITY", _wrap_dwg_object_to_PROXY_ENTITY, METH_O, NULL},
	 { "dwg_object_to_RAY", _wrap_dwg_object_to_RAY, METH_O, NULL},
	 { "dwg_object_to_REGION", _wrap_dwg_object_to_REGION, METH_O, NULL},
	 { "dwg_object_to_REPEAT", _wrap_dwg_object_to_REPEAT, METH_O, NULL},
	 { "dwg_object_to_SECTIONOBJECT", _wrap_dwg_object_to_SECTIONOBJECT, METH_O, NULL},
	 { "dwg_object_to_SEQEND", _wrap_dwg_object_to_SEQEND, METH_O, NULL},
	 { "dwg_object_to_SHAPE", _wrap_dwg_object_to_SHAPE, METH_O, NULL},
	 { "dwg_object_to_SOLID", _wrap_dwg_object_to_SOLID, METH_O, NULL},
	 { "dwg_object_to_SPLINE", _wrap_dwg_object_to_SPLINE, METH_O, NULL},
	 { "dwg_object_to_TEXT", _wrap_dwg_object_to_TEXT, METH_O, NULL},
	 { "dwg_object_to_TOLERANCE", _wrap_dwg_object_to_TOLERANCE, METH_O, NULL},
	 { "dwg_object_to_TRACE", _wrap_dwg_object_to_TRACE, METH_O, NULL},
	 { "dwg_object_to_UNKNOWN_ENT", _wrap_dwg_object_to_UNKNOWN_ENT, METH_O, NULL},
	 { "dwg_object_to_VERTEX_2D", _wrap_dwg_object_to_VERTEX_2D, METH_O, NULL},
	 { "dwg_object_to_VERTEX_3D", _wrap_dwg_object_to_VERTEX_3D, METH_O, NULL},
	 { "dwg_object_to_VERTEX_MESH", _wrap_dwg_object_to_VERTEX_MESH, METH_O, NULL},
	 { "dwg_object_to_VERTEX_PFACE", _wrap_dwg_object_to_VERTEX_PFACE, METH_O, NULL},
	 { "dwg_object_to_VERTEX_PFACE_FACE", _wrap_dwg_object_to_VERTEX_PFACE_FACE, METH_O, NULL},
	 { "dwg_object_to_VIEWPORT", _wrap_dwg_object_to_VIEWPORT, METH_O, NULL},
	 { "dwg_object_to_WIPEOUT", _wrap_dwg_object_to_WIPEOUT, METH_O, NULL},
	 { "dwg_object_to_XLINE", _wrap_dwg_object_to_XLINE, METH_O, NULL},
	 { "dwg_object_to_ARC_DIMENSION", _wrap_dwg_object_to_ARC_DIMENSION, METH_O, NULL},
	 { "dwg_object_to_HELIX", _wrap_dwg_object_to_HELIX, METH_O, NULL},
	 { "dwg_object_to_LARGE_RADIAL_DIMENSION", _wrap_dwg_object_to_LARGE_RADIAL_DIMENSION, METH_O, NULL},
	 { "dwg_object_to_LAYOUTPRINTCONFIG", _wrap_dwg_object_to_LAYOUTPRINTCONFIG, METH_O, NULL},
	 { "dwg_object_to_PLANESURFACE", _wrap_dwg_object_to_PLANESURFACE, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUD", _wrap_dwg_object_to_POINTCLOUD, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDEX", _wrap_dwg_object_to_POINTCLOUDEX, METH_O, NULL},
	 { "dwg_object_to_ACSH_BOOLEAN_CLASS", _wrap_dwg_object_to_ACSH_BOOLEAN_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_BOX_CLASS", _wrap_dwg_object_to_ACSH_BOX_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_CONE_CLASS", _wrap_dwg_object_to_ACSH_CONE_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_CYLINDER_CLASS", _wrap_dwg_object_to_ACSH_CYLINDER_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_FILLET_CLASS", _wrap_dwg_object_to_ACSH_FILLET_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_HISTORY_CLASS", _wrap_dwg_object_to_ACSH_HISTORY_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_SPHERE_CLASS", _wrap_dwg_object_to_ACSH_SPHERE_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_TORUS_CLASS", _wrap_dwg_object_to_ACSH_TORUS_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_WEDGE_CLASS", _wrap_dwg_object_to_ACSH_WEDGE_CLASS, METH_O, NULL},
	 { "dwg_object_to_APPID", _wrap_dwg_object_to_APPID, METH_O, NULL},
	 { "dwg_object_to_APPID_CONTROL", _wrap_dwg_object_to_APPID_CONTROL, METH_O, NULL},
	 { "dwg_object_to_ASSOCGEOMDEPENDENCY", _wrap_dwg_object_to_ASSOCGEOMDEPENDENCY, METH_O, NULL},
	 { "dwg_object_to_ASSOCNETWORK", _wrap_dwg_object_to_ASSOCNETWORK, METH_O, NULL},
	 { "dwg_object_to_BLOCKALIGNMENTGRIP", _wrap_dwg_object_to_BLOCKALIGNMENTGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKALIGNMENTPARAMETER", _wrap_dwg_object_to_BLOCKALIGNMENTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKBASEPOINTPARAMETER", _wrap_dwg_object_to_BLOCKBASEPOINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKFLIPACTION", _wrap_dwg_object_to_BLOCKFLIPACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKFLIPGRIP", _wrap_dwg_object_to_BLOCKFLIPGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKFLIPPARAMETER", _wrap_dwg_object_to_BLOCKFLIPPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKGRIPLOCATIONCOMPONENT", _wrap_dwg_object_to_BLOCKGRIPLOCATIONCOMPONENT, METH_O, NULL},
	 { "dwg_object_to_BLOCKLINEARGRIP", _wrap_dwg_object_to_BLOCKLINEARGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKLOOKUPGRIP", _wrap_dwg_object_to_BLOCKLOOKUPGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKMOVEACTION", _wrap_dwg_object_to_BLOCKMOVEACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKROTATEACTION", _wrap_dwg_object_to_BLOCKROTATEACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKROTATIONGRIP", _wrap_dwg_object_to_BLOCKROTATIONGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKSCALEACTION", _wrap_dwg_object_to_BLOCKSCALEACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKVISIBILITYGRIP", _wrap_dwg_object_to_BLOCKVISIBILITYGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCK_CONTROL", _wrap_dwg_object_to_BLOCK_CONTROL, METH_O, NULL},
	 { "dwg_object_to_BLOCK_HEADER", _wrap_dwg_object_to_BLOCK_HEADER, METH_O, NULL},
	 { "dwg_object_to_CELLSTYLEMAP", _wrap_dwg_object_to_CELLSTYLEMAP, METH_O, NULL},
	 { "dwg_object_to_DETAILVIEWSTYLE", _wrap_dwg_object_to_DETAILVIEWSTYLE, METH_O, NULL},
	 { "dwg_object_to_DICTIONARY", _wrap_dwg_object_to_DICTIONARY, METH_O, NULL},
	 { "dwg_object_to_DICTIONARYVAR", _wrap_dwg_object_to_DICTIONARYVAR, METH_O, NULL},
	 { "dwg_object_to_DICTIONARYWDFLT", _wrap_dwg_object_to_DICTIONARYWDFLT, METH_O, NULL},
	 { "dwg_object_to_DIMSTYLE", _wrap_dwg_object_to_DIMSTYLE, METH_O, NULL},
	 { "dwg_object_to_DIMSTYLE_CONTROL", _wrap_dwg_object_to_DIMSTYLE_CONTROL, METH_O, NULL},
	 { "dwg_object_to_DUMMY", _wrap_dwg_object_to_DUMMY, METH_O, NULL},
	 { "dwg_object_to_DYNAMICBLOCKPURGEPREVENTER", _wrap_dwg_object_to_DYNAMICBLOCKPURGEPREVENTER, METH_O, NULL},
	 { "dwg_object_to_FIELD", _wrap_dwg_object_to_FIELD, METH_O, NULL},
	 { "dwg_object_to_FIELDLIST", _wrap_dwg_object_to_FIELDLIST, METH_O, NULL},
	 { "dwg_object_to_GEODATA", _wrap_dwg_object_to_GEODATA, METH_O, NULL},
	 { "dwg_object_to_GROUP", _wrap_dwg_object_to_GROUP, METH_O, NULL},
	 { "dwg_object_to_IDBUFFER", _wrap_dwg_object_to_IDBUFFER, METH_O, NULL},
	 { "dwg_object_to_IMAGEDEF", _wrap_dwg_object_to_IMAGEDEF, METH_O, NULL},
	 { "dwg_object_to_IMAGEDEF_REACTOR", _wrap_dwg_object_to_IMAGEDEF_REACTOR, METH_O, NULL},
	 { "dwg_object_to_INDEX", _wrap_dwg_object_to_INDEX, METH_O, NULL},
	 { "dwg_object_to_LAYER", _wrap_dwg_object_to_LAYER, METH_O, NULL},
	 { "dwg_object_to_LAYERFILTER", _wrap_dwg_object_to_LAYERFILTER, METH_O, NULL},
	 { "dwg_object_to_LAYER_CONTROL", _wrap_dwg_object_to_LAYER_CONTROL, METH_O, NULL},
	 { "dwg_object_to_LAYER_INDEX", _wrap_dwg_object_to_LAYER_INDEX, METH_O, NULL},
	 { "dwg_object_to_LAYOUT", _wrap_dwg_object_to_LAYOUT, METH_O, NULL},
	 { "dwg_object_to_LONG_TRANSACTION", _wrap_dwg_object_to_LONG_TRANSACTION, METH_O, NULL},
	 { "dwg_object_to_LTYPE", _wrap_dwg_object_to_LTYPE, METH_O, NULL},
	 { "dwg_object_to_LTYPE_CONTROL", _wrap_dwg_object_to_LTYPE_CONTROL, METH_O, NULL},
	 { "dwg_object_to_MLINESTYLE", _wrap_dwg_object_to_MLINESTYLE, METH_O, NULL},
	 { "dwg_object_to_PLACEHOLDER", _wrap_dwg_object_to_PLACEHOLDER, METH_O, NULL},
	 { "dwg_object_to_PLOTSETTINGS", _wrap_dwg_object_to_PLOTSETTINGS, METH_O, NULL},
	 { "dwg_object_to_RASTERVARIABLES", _wrap_dwg_object_to_RASTERVARIABLES, METH_O, NULL},
	 { "dwg_object_to_RENDERENVIRONMENT", _wrap_dwg_object_to_RENDERENVIRONMENT, METH_O, NULL},
	 { "dwg_object_to_SCALE", _wrap_dwg_object_to_SCALE, METH_O, NULL},
	 { "dwg_object_to_SECTIONVIEWSTYLE", _wrap_dwg_object_to_SECTIONVIEWSTYLE, METH_O, NULL},
	 { "dwg_object_to_SECTION_MANAGER", _wrap_dwg_object_to_SECTION_MANAGER, METH_O, NULL},
	 { "dwg_object_to_SORTENTSTABLE", _wrap_dwg_object_to_SORTENTSTABLE, METH_O, NULL},
	 { "dwg_object_to_SPATIAL_FILTER", _wrap_dwg_object_to_SPATIAL_FILTER, METH_O, NULL},
	 { "dwg_object_to_STYLE", _wrap_dwg_object_to_STYLE, METH_O, NULL},
	 { "dwg_object_to_STYLE_CONTROL", _wrap_dwg_object_to_STYLE_CONTROL, METH_O, NULL},
	 { "dwg_object_to_SUN", _wrap_dwg_object_to_SUN, METH_O, NULL},
	 { "dwg_object_to_TABLEGEOMETRY", _wrap_dwg_object_to_TABLEGEOMETRY, METH_O, NULL},
	 { "dwg_object_to_UCS", _wrap_dwg_object_to_UCS, METH_O, NULL},
	 { "dwg_object_to_UCS_CONTROL", _wrap_dwg_object_to_UCS_CONTROL, METH_O, NULL},
	 { "dwg_object_to_UNKNOWN_OBJ", _wrap_dwg_object_to_UNKNOWN_OBJ, METH_O, NULL},
	 { "dwg_object_to_VBA_PROJECT", _wrap_dwg_object_to_VBA_PROJECT, METH_O, NULL},
	 { "dwg_object_to_VIEW", _wrap_dwg_object_to_VIEW, METH_O, NULL},
	 { "dwg_object_to_VIEW_CONTROL", _wrap_dwg_object_to_VIEW_CONTROL, METH_O, NULL},
	 { "dwg_object_to_VISUALSTYLE", _wrap_dwg_object_to_VISUALSTYLE, METH_O, NULL},
	 { "dwg_object_to_VPORT", _wrap_dwg_object_to_VPORT, METH_O, NULL},
	 { "dwg_object_to_VPORT_CONTROL", _wrap_dwg_object_to_VPORT_CONTROL, METH_O, NULL},
	 { "dwg_object_to_VX_CONTROL", _wrap_dwg_object_to_VX_CONTROL, METH_O, NULL},
	 { "dwg_object_to_VX_TABLE_RECORD", _wrap_dwg_object_to_VX_TABLE_RECORD, METH_O, NULL},
	 { "dwg_object_to_WIPEOUTVARIABLES", _wrap_dwg_object_to_WIPEOUTVARIABLES, METH_O, NULL},
	 { "dwg_object_to_XRECORD", _wrap_dwg_object_to_XRECORD, METH_O, NULL},
	 { "dwg_object_to_PDFDEFINITION", _wrap_dwg_object_to_PDFDEFINITION, METH_O, NULL},
	 { "dwg_object_to_DGNDEFINITION", _wrap_dwg_object_to_DGNDEFINITION, METH_O, NULL},
	 { "dwg_object_to_DWFDEFINITION", _wrap_dwg_object_to_DWFDEFINITION, METH_O, NULL},
	 { "dwg_object_to_ACSH_BREP_CLASS", _wrap_dwg_object_to_ACSH_BREP_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_CHAMFER_CLASS", _wrap_dwg_object_to_ACSH_CHAMFER_CLASS, METH_O, NULL},
	 { "dwg_object_to_ACSH_PYRAMID_CLASS", _wrap_dwg_object_to_ACSH_PYRAMID_CLASS, METH_O, NULL},
	 { "dwg_object_to_ALDIMOBJECTCONTEXTDATA", _wrap_dwg_object_to_ALDIMOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_ASSOC2DCONSTRAINTGROUP", _wrap_dwg_object_to_ASSOC2DCONSTRAINTGROUP, METH_O, NULL},
	 { "dwg_object_to_ASSOCACTION", _wrap_dwg_object_to_ASSOCACTION, METH_O, NULL},
	 { "dwg_object_to_ASSOCACTIONPARAM", _wrap_dwg_object_to_ASSOCACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCARRAYACTIONBODY", _wrap_dwg_object_to_ASSOCARRAYACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCASMBODYACTIONPARAM", _wrap_dwg_object_to_ASSOCASMBODYACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCBLENDSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCBLENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCCOMPOUNDACTIONPARAM", _wrap_dwg_object_to_ASSOCCOMPOUNDACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCDEPENDENCY", _wrap_dwg_object_to_ASSOCDEPENDENCY, METH_O, NULL},
	 { "dwg_object_to_ASSOCDIMDEPENDENCYBODY", _wrap_dwg_object_to_ASSOCDIMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCEXTENDSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCEXTENDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCEXTRUDEDSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCEXTRUDEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCFACEACTIONPARAM", _wrap_dwg_object_to_ASSOCFACEACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCFILLETSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCFILLETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCLOFTEDSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCLOFTEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCNETWORKSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCNETWORKSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCOBJECTACTIONPARAM", _wrap_dwg_object_to_ASSOCOBJECTACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCOFFSETSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCOFFSETSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCOSNAPPOINTREFACTIONPARAM", _wrap_dwg_object_to_ASSOCOSNAPPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCPATCHSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCPATCHSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCPATHACTIONPARAM", _wrap_dwg_object_to_ASSOCPATHACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCPLANESURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCPLANESURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCPOINTREFACTIONPARAM", _wrap_dwg_object_to_ASSOCPOINTREFACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_ASSOCREVOLVEDSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCREVOLVEDSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCTRIMSURFACEACTIONBODY", _wrap_dwg_object_to_ASSOCTRIMSURFACEACTIONBODY, METH_O, NULL},
	 { "dwg_object_to_ASSOCVALUEDEPENDENCY", _wrap_dwg_object_to_ASSOCVALUEDEPENDENCY, METH_O, NULL},
	 { "dwg_object_to_ASSOCVARIABLE", _wrap_dwg_object_to_ASSOCVARIABLE, METH_O, NULL},
	 { "dwg_object_to_ASSOCVERTEXACTIONPARAM", _wrap_dwg_object_to_ASSOCVERTEXACTIONPARAM, METH_O, NULL},
	 { "dwg_object_to_BLKREFOBJECTCONTEXTDATA", _wrap_dwg_object_to_BLKREFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_BLOCKALIGNEDCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKALIGNEDCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKANGULARCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKANGULARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKARRAYACTION", _wrap_dwg_object_to_BLOCKARRAYACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKDIAMETRICCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKDIAMETRICCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKHORIZONTALCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKHORIZONTALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKLINEARCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKLINEARCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKLINEARPARAMETER", _wrap_dwg_object_to_BLOCKLINEARPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKLOOKUPACTION", _wrap_dwg_object_to_BLOCKLOOKUPACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKLOOKUPPARAMETER", _wrap_dwg_object_to_BLOCKLOOKUPPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKPARAMDEPENDENCYBODY", _wrap_dwg_object_to_BLOCKPARAMDEPENDENCYBODY, METH_O, NULL},
	 { "dwg_object_to_BLOCKPOINTPARAMETER", _wrap_dwg_object_to_BLOCKPOINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKPOLARGRIP", _wrap_dwg_object_to_BLOCKPOLARGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKPOLARPARAMETER", _wrap_dwg_object_to_BLOCKPOLARPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKPOLARSTRETCHACTION", _wrap_dwg_object_to_BLOCKPOLARSTRETCHACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKRADIALCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKRADIALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKREPRESENTATION", _wrap_dwg_object_to_BLOCKREPRESENTATION, METH_O, NULL},
	 { "dwg_object_to_BLOCKROTATIONPARAMETER", _wrap_dwg_object_to_BLOCKROTATIONPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKSTRETCHACTION", _wrap_dwg_object_to_BLOCKSTRETCHACTION, METH_O, NULL},
	 { "dwg_object_to_BLOCKUSERPARAMETER", _wrap_dwg_object_to_BLOCKUSERPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKVERTICALCONSTRAINTPARAMETER", _wrap_dwg_object_to_BLOCKVERTICALCONSTRAINTPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKVISIBILITYPARAMETER", _wrap_dwg_object_to_BLOCKVISIBILITYPARAMETER, METH_O, NULL},
	 { "dwg_object_to_BLOCKXYGRIP", _wrap_dwg_object_to_BLOCKXYGRIP, METH_O, NULL},
	 { "dwg_object_to_BLOCKXYPARAMETER", _wrap_dwg_object_to_BLOCKXYPARAMETER, METH_O, NULL},
	 { "dwg_object_to_DATALINK", _wrap_dwg_object_to_DATALINK, METH_O, NULL},
	 { "dwg_object_to_DBCOLOR", _wrap_dwg_object_to_DBCOLOR, METH_O, NULL},
	 { "dwg_object_to_EVALUATION_GRAPH", _wrap_dwg_object_to_EVALUATION_GRAPH, METH_O, NULL},
	 { "dwg_object_to_FCFOBJECTCONTEXTDATA", _wrap_dwg_object_to_FCFOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_GRADIENT_BACKGROUND", _wrap_dwg_object_to_GRADIENT_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_GROUND_PLANE_BACKGROUND", _wrap_dwg_object_to_GROUND_PLANE_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_IBL_BACKGROUND", _wrap_dwg_object_to_IBL_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_IMAGE_BACKGROUND", _wrap_dwg_object_to_IMAGE_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_LEADEROBJECTCONTEXTDATA", _wrap_dwg_object_to_LEADEROBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_LIGHTLIST", _wrap_dwg_object_to_LIGHTLIST, METH_O, NULL},
	 { "dwg_object_to_MATERIAL", _wrap_dwg_object_to_MATERIAL, METH_O, NULL},
	 { "dwg_object_to_MENTALRAYRENDERSETTINGS", _wrap_dwg_object_to_MENTALRAYRENDERSETTINGS, METH_O, NULL},
	 { "dwg_object_to_MLEADERSTYLE", _wrap_dwg_object_to_MLEADERSTYLE, METH_O, NULL},
	 { "dwg_object_to_MTEXTOBJECTCONTEXTDATA", _wrap_dwg_object_to_MTEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_OBJECT_PTR", _wrap_dwg_object_to_OBJECT_PTR, METH_O, NULL},
	 { "dwg_object_to_PARTIAL_VIEWING_INDEX", _wrap_dwg_object_to_PARTIAL_VIEWING_INDEX, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDCOLORMAP", _wrap_dwg_object_to_POINTCLOUDCOLORMAP, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDDEF", _wrap_dwg_object_to_POINTCLOUDDEF, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDDEFEX", _wrap_dwg_object_to_POINTCLOUDDEFEX, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDDEF_REACTOR", _wrap_dwg_object_to_POINTCLOUDDEF_REACTOR, METH_O, NULL},
	 { "dwg_object_to_POINTCLOUDDEF_REACTOR_EX", _wrap_dwg_object_to_POINTCLOUDDEF_REACTOR_EX, METH_O, NULL},
	 { "dwg_object_to_PROXY_OBJECT", _wrap_dwg_object_to_PROXY_OBJECT, METH_O, NULL},
	 { "dwg_object_to_RAPIDRTRENDERSETTINGS", _wrap_dwg_object_to_RAPIDRTRENDERSETTINGS, METH_O, NULL},
	 { "dwg_object_to_RENDERENTRY", _wrap_dwg_object_to_RENDERENTRY, METH_O, NULL},
	 { "dwg_object_to_RENDERGLOBAL", _wrap_dwg_object_to_RENDERGLOBAL, METH_O, NULL},
	 { "dwg_object_to_RENDERSETTINGS", _wrap_dwg_object_to_RENDERSETTINGS, METH_O, NULL},
	 { "dwg_object_to_SECTION_SETTINGS", _wrap_dwg_object_to_SECTION_SETTINGS, METH_O, NULL},
	 { "dwg_object_to_SKYLIGHT_BACKGROUND", _wrap_dwg_object_to_SKYLIGHT_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_SOLID_BACKGROUND", _wrap_dwg_object_to_SOLID_BACKGROUND, METH_O, NULL},
	 { "dwg_object_to_SPATIAL_INDEX", _wrap_dwg_object_to_SPATIAL_INDEX, METH_O, NULL},
	 { "dwg_object_to_TABLESTYLE", _wrap_dwg_object_to_TABLESTYLE, METH_O, NULL},
	 { "dwg_object_to_TEXTOBJECTCONTEXTDATA", _wrap_dwg_object_to_TEXTOBJECTCONTEXTDATA, METH_O, NULL},
	 { "dwg_object_to_ASSOCARRAYMODIFYPARAMETERS", _wrap_dwg_object_to_ASSOCARRAYMODIFYPARAMETERS, METH_O, NULL},
	 { "dwg_object_to_ASSOCARRAYPATHPARAMETERS", _wrap_dwg_object_to_ASSOCARRAYPATHPARAMETERS, METH_O, NULL},
	 { "dwg_object_to_ASSOCARRAYPOLARPARAMETERS", _wrap_dwg_object_to_ASSOCARRAYPOLARPARAMETERS, METH_O, NULL},
	 { "dwg_object_to_ASSOCARRAYRECTANGULARPARAMETERS", _wrap_dwg_object_to_ASSOCARRAYRECTANGULARPARAMETERS, METH_O, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_DWG_CLASS_STABILITY = {"_p_DWG_CLASS_STABILITY", "Dwg_Class_Stability *|enum DWG_CLASS_STABILITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_COLOR_METHOD = {"_p_DWG_COLOR_METHOD", "Dwg_Color_Method *|enum DWG_COLOR_METHOD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_ENTITY_SECTIONS = {"_p_DWG_ENTITY_SECTIONS", "Dwg_Entity_Sections *|enum DWG_ENTITY_SECTIONS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_ERROR = {"_p_DWG_ERROR", "Dwg_Error *|enum DWG_ERROR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_HDL_CODE = {"_p_DWG_HDL_CODE", "Dwg_Hdl_Code *|enum DWG_HDL_CODE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_OBJECT_SUPERTYPE = {"_p_DWG_OBJECT_SUPERTYPE", "Dwg_Object_Supertype *|enum DWG_OBJECT_SUPERTYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_OBJECT_TYPE = {"_p_DWG_OBJECT_TYPE", "Dwg_Object_Type *|enum DWG_OBJECT_TYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_OBJECT_TYPE_R11 = {"_p_DWG_OBJECT_TYPE_R11", "Dwg_Object_Type_r11 *|enum DWG_OBJECT_TYPE_R11 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_SECTION_TYPE = {"_p_DWG_SECTION_TYPE", "Dwg_Section_Type *|enum DWG_SECTION_TYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_SECTION_TYPE_R11 = {"_p_DWG_SECTION_TYPE_R11", "Dwg_Section_Type_r11 *|enum DWG_SECTION_TYPE_R11 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_SECTION_TYPE_R13 = {"_p_DWG_SECTION_TYPE_R13", "Dwg_Section_Type_r13 *|enum DWG_SECTION_TYPE_R13 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DWG_VERSION_TYPE = {"_p_DWG_VERSION_TYPE", "Dwg_Version_Type *|enum DWG_VERSION_TYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dwg_Section_Info = {"_p_Dwg_Section_Info", "Dwg_Section_Info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dwg_Section_InfoHdr = {"_p_Dwg_Section_InfoHdr", "Dwg_Section_InfoHdr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RESBUF_VALUE_TYPE = {"_p_RESBUF_VALUE_TYPE", "Dwg_Resbuf_Value_Type *|enum RESBUF_VALUE_TYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_3DSOLID_material = {"_p__dwg_3DSOLID_material", "Dwg_3DSOLID_material *|struct _dwg_3DSOLID_material *|_dwg_3DSOLID_material *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_3DSOLID_silhouette = {"_p__dwg_3DSOLID_silhouette", "Dwg_3DSOLID_silhouette *|struct _dwg_3DSOLID_silhouette *|_dwg_3DSOLID_silhouette *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_3DSOLID_wire = {"_p__dwg_3DSOLID_wire", "Dwg_3DSOLID_wire *|struct _dwg_3DSOLID_wire *|_dwg_3DSOLID_wire *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ACSH_HistoryNode = {"_p__dwg_ACSH_HistoryNode", "Dwg_ACSH_HistoryNode *|struct _dwg_ACSH_HistoryNode *|_dwg_ACSH_HistoryNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ACSH_SubentColor = {"_p__dwg_ACSH_SubentColor", "Dwg_ACSH_SubentColor *|struct _dwg_ACSH_SubentColor *|_dwg_ACSH_SubentColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ACSH_SubentMaterial = {"_p__dwg_ACSH_SubentMaterial", "Dwg_ACSH_SubentMaterial *|struct _dwg_ACSH_SubentMaterial *|_dwg_ACSH_SubentMaterial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ACTIONBODY = {"_p__dwg_ACTIONBODY", "Dwg_ACTIONBODY *|struct _dwg_ACTIONBODY *|_dwg_ACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ARRAYITEMLOCATOR = {"_p__dwg_ARRAYITEMLOCATOR", "Dwg_ARRAYITEMLOCATOR *|struct _dwg_ARRAYITEMLOCATOR *|_dwg_ARRAYITEMLOCATOR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ASSOCACTIONBODY_action = {"_p__dwg_ASSOCACTIONBODY_action", "Dwg_ASSOCACTIONBODY_action *|struct _dwg_ASSOCACTIONBODY_action *|_dwg_ASSOCACTIONBODY_action *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ASSOCACTION_Deps = {"_p__dwg_ASSOCACTION_Deps", "Dwg_ASSOCACTION_Deps *|struct _dwg_ASSOCACTION_Deps *|_dwg_ASSOCACTION_Deps *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ASSOCARRAYITEM = {"_p__dwg_ASSOCARRAYITEM", "Dwg_ASSOCARRAYITEM *|struct _dwg_ASSOCARRAYITEM *|_dwg_ASSOCARRAYITEM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ASSOCPARAMBASEDACTIONBODY = {"_p__dwg_ASSOCPARAMBASEDACTIONBODY", "Dwg_ASSOCPARAMBASEDACTIONBODY *|struct _dwg_ASSOCPARAMBASEDACTIONBODY *|_dwg_ASSOCPARAMBASEDACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ASSOCSURFACEACTIONBODY = {"_p__dwg_ASSOCSURFACEACTIONBODY", "Dwg_ASSOCSURFACEACTIONBODY *|struct _dwg_ASSOCSURFACEACTIONBODY *|_dwg_ASSOCSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDbMTextObjectEmbedded = {"_p__dwg_AcDbMTextObjectEmbedded", "Dwg_AcDbMTextObjectEmbedded *|struct _dwg_AcDbMTextObjectEmbedded *|_dwg_AcDbMTextObjectEmbedded *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs = {"_p__dwg_AcDs", "Dwg_AcDs *|struct _dwg_AcDs *|_dwg_AcDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Data = {"_p__dwg_AcDs_Data", "Dwg_AcDs_Data *|struct _dwg_AcDs_Data *|_dwg_AcDs_Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataBlob = {"_p__dwg_AcDs_DataBlob", "Dwg_AcDs_DataBlob *|struct _dwg_AcDs_DataBlob *|_dwg_AcDs_DataBlob *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataBlob01 = {"_p__dwg_AcDs_DataBlob01", "Dwg_AcDs_DataBlob01 *|struct _dwg_AcDs_DataBlob01 *|_dwg_AcDs_DataBlob01 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataBlobRef = {"_p__dwg_AcDs_DataBlobRef", "Dwg_AcDs_DataBlobRef *|struct _dwg_AcDs_DataBlobRef *|_dwg_AcDs_DataBlobRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataBlobRef_Page = {"_p__dwg_AcDs_DataBlobRef_Page", "Dwg_AcDs_DataBlobRef_Page *|struct _dwg_AcDs_DataBlobRef_Page *|_dwg_AcDs_DataBlobRef_Page *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataIndex = {"_p__dwg_AcDs_DataIndex", "Dwg_AcDs_DataIndex *|struct _dwg_AcDs_DataIndex *|_dwg_AcDs_DataIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_DataIndex_Entry = {"_p__dwg_AcDs_DataIndex_Entry", "Dwg_AcDs_DataIndex_Entry *|struct _dwg_AcDs_DataIndex_Entry *|_dwg_AcDs_DataIndex_Entry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Data_Record = {"_p__dwg_AcDs_Data_Record", "Dwg_AcDs_Data_Record *|struct _dwg_AcDs_Data_Record *|_dwg_AcDs_Data_Record *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Data_RecordHdr = {"_p__dwg_AcDs_Data_RecordHdr", "Dwg_AcDs_Data_RecordHdr *|struct _dwg_AcDs_Data_RecordHdr *|_dwg_AcDs_Data_RecordHdr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Schema = {"_p__dwg_AcDs_Schema", "Dwg_AcDs_Schema *|struct _dwg_AcDs_Schema *|_dwg_AcDs_Schema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_SchemaData = {"_p__dwg_AcDs_SchemaData", "Dwg_AcDs_SchemaData *|struct _dwg_AcDs_SchemaData *|_dwg_AcDs_SchemaData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_SchemaData_UProp = {"_p__dwg_AcDs_SchemaData_UProp", "Dwg_AcDs_SchemaData_UProp *|struct _dwg_AcDs_SchemaData_UProp *|_dwg_AcDs_SchemaData_UProp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_SchemaIndex = {"_p__dwg_AcDs_SchemaIndex", "Dwg_AcDs_SchemaIndex *|struct _dwg_AcDs_SchemaIndex *|_dwg_AcDs_SchemaIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_SchemaIndex_Prop = {"_p__dwg_AcDs_SchemaIndex_Prop", "Dwg_AcDs_SchemaIndex_Prop *|struct _dwg_AcDs_SchemaIndex_Prop *|_dwg_AcDs_SchemaIndex_Prop *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Schema_Prop = {"_p__dwg_AcDs_Schema_Prop", "Dwg_AcDs_Schema_Prop *|struct _dwg_AcDs_Schema_Prop *|_dwg_AcDs_Schema_Prop *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Search = {"_p__dwg_AcDs_Search", "Dwg_AcDs_Search *|struct _dwg_AcDs_Search *|_dwg_AcDs_Search *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Search_Data = {"_p__dwg_AcDs_Search_Data", "Dwg_AcDs_Search_Data *|struct _dwg_AcDs_Search_Data *|_dwg_AcDs_Search_Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Search_IdIdx = {"_p__dwg_AcDs_Search_IdIdx", "Dwg_AcDs_Search_IdIdx *|struct _dwg_AcDs_Search_IdIdx *|_dwg_AcDs_Search_IdIdx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Search_IdIdxs = {"_p__dwg_AcDs_Search_IdIdxs", "Dwg_AcDs_Search_IdIdxs *|struct _dwg_AcDs_Search_IdIdxs *|_dwg_AcDs_Search_IdIdxs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_Segment = {"_p__dwg_AcDs_Segment", "Dwg_AcDs_Segment *|struct _dwg_AcDs_Segment *|_dwg_AcDs_Segment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_AcDs_SegmentIndex = {"_p__dwg_AcDs_SegmentIndex", "Dwg_AcDs_SegmentIndex *|struct _dwg_AcDs_SegmentIndex *|_dwg_AcDs_SegmentIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKACTION_connectionpts = {"_p__dwg_BLOCKACTION_connectionpts", "Dwg_BLOCKACTION_connectionpts *|struct _dwg_BLOCKACTION_connectionpts *|_dwg_BLOCKACTION_connectionpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKLOOKUPACTION_lut = {"_p__dwg_BLOCKLOOKUPACTION_lut", "Dwg_BLOCKLOOKUPACTION_lut *|struct _dwg_BLOCKLOOKUPACTION_lut *|_dwg_BLOCKLOOKUPACTION_lut *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKPARAMETER_PropInfo = {"_p__dwg_BLOCKPARAMETER_PropInfo", "Dwg_BLOCKPARAMETER_PropInfo *|struct _dwg_BLOCKPARAMETER_PropInfo *|_dwg_BLOCKPARAMETER_PropInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKPARAMETER_connection = {"_p__dwg_BLOCKPARAMETER_connection", "Dwg_BLOCKPARAMETER_connection *|struct _dwg_BLOCKPARAMETER_connection *|_dwg_BLOCKPARAMETER_connection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKPARAMVALUESET = {"_p__dwg_BLOCKPARAMVALUESET", "Dwg_BLOCKPARAMVALUESET *|struct _dwg_BLOCKPARAMVALUESET *|_dwg_BLOCKPARAMVALUESET *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKSTRETCHACTION_codes = {"_p__dwg_BLOCKSTRETCHACTION_codes", "Dwg_BLOCKSTRETCHACTION_codes *|struct _dwg_BLOCKSTRETCHACTION_codes *|_dwg_BLOCKSTRETCHACTION_codes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKSTRETCHACTION_handles = {"_p__dwg_BLOCKSTRETCHACTION_handles", "Dwg_BLOCKSTRETCHACTION_handles *|struct _dwg_BLOCKSTRETCHACTION_handles *|_dwg_BLOCKSTRETCHACTION_handles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_BLOCKVISIBILITYPARAMETER_state = {"_p__dwg_BLOCKVISIBILITYPARAMETER_state", "Dwg_BLOCKVISIBILITYPARAMETER_state *|struct _dwg_BLOCKVISIBILITYPARAMETER_state *|_dwg_BLOCKVISIBILITYPARAMETER_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_COMPOUNDOBJECTID = {"_p__dwg_COMPOUNDOBJECTID", "Dwg_COMPOUNDOBJECTID *|struct _dwg_COMPOUNDOBJECTID *|_dwg_COMPOUNDOBJECTID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_CONSTRAINTGROUPNODE = {"_p__dwg_CONSTRAINTGROUPNODE", "Dwg_CONSTRAINTGROUPNODE *|struct _dwg_CONSTRAINTGROUPNODE *|_dwg_CONSTRAINTGROUPNODE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_CONTEXTDATA_dict = {"_p__dwg_CONTEXTDATA_dict", "Dwg_CONTEXTDATA_dict *|struct _dwg_CONTEXTDATA_dict *|_dwg_CONTEXTDATA_dict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_CONTEXTDATA_submgr = {"_p__dwg_CONTEXTDATA_submgr", "Dwg_CONTEXTDATA_submgr *|struct _dwg_CONTEXTDATA_submgr *|_dwg_CONTEXTDATA_submgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_CellContentGeometry = {"_p__dwg_CellContentGeometry", "Dwg_CellContentGeometry *|struct _dwg_CellContentGeometry *|_dwg_CellContentGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_CellStyle = {"_p__dwg_CellStyle", "Dwg_CellStyle *|struct _dwg_CellStyle *|_dwg_CellStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ColorRamp = {"_p__dwg_ColorRamp", "Dwg_ColorRamp *|struct _dwg_ColorRamp *|_dwg_ColorRamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_ContentFormat = {"_p__dwg_ContentFormat", "Dwg_ContentFormat *|struct _dwg_ContentFormat *|_dwg_ContentFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_DATALINK_customdata = {"_p__dwg_DATALINK_customdata", "Dwg_DATALINK_customdata *|struct _dwg_DATALINK_customdata *|_dwg_DATALINK_customdata *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_DATATABLE_column = {"_p__dwg_DATATABLE_column", "Dwg_DATATABLE_column *|struct _dwg_DATATABLE_column *|_dwg_DATATABLE_column *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_DATATABLE_row = {"_p__dwg_DATATABLE_row", "Dwg_DATATABLE_row *|struct _dwg_DATATABLE_row *|_dwg_DATATABLE_row *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_DIMASSOC_Ref = {"_p__dwg_DIMASSOC_Ref", "Dwg_DIMASSOC_Ref *|struct _dwg_DIMASSOC_Ref *|_dwg_DIMASSOC_Ref *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_DIMENSION_common = {"_p__dwg_DIMENSION_common", "Dwg_DIMENSION_common *|struct _dwg_DIMENSION_common *|_dwg_DIMENSION_common *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EVAL_Edge = {"_p__dwg_EVAL_Edge", "Dwg_EVAL_Edge *|struct _dwg_EVAL_Edge *|_dwg_EVAL_Edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EVAL_Node = {"_p__dwg_EVAL_Node", "Dwg_EVAL_Node *|struct _dwg_EVAL_Node *|_dwg_EVAL_Node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EvalExpr = {"_p__dwg_EvalExpr", "Dwg_EvalExpr *|struct _dwg_EvalExpr *|_dwg_EvalExpr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EvalExpr_value = {"_p__dwg_EvalExpr_value", "_dwg_EvalExpr_value *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EvalVariant = {"_p__dwg_EvalVariant", "Dwg_EvalVariant *|struct _dwg_EvalVariant *|_dwg_EvalVariant *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_EvalVariant_u = {"_p__dwg_EvalVariant_u", "_dwg_EvalVariant_u *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_FIELD_ChildValue = {"_p__dwg_FIELD_ChildValue", "Dwg_FIELD_ChildValue *|struct _dwg_FIELD_ChildValue *|_dwg_FIELD_ChildValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_FileDepList_Files = {"_p__dwg_FileDepList_Files", "Dwg_FileDepList_Files *|struct _dwg_FileDepList_Files *|_dwg_FileDepList_Files *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_FormattedTableData = {"_p__dwg_FormattedTableData", "Dwg_FormattedTableData *|struct _dwg_FormattedTableData *|_dwg_FormattedTableData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_FormattedTableMerged = {"_p__dwg_FormattedTableMerged", "Dwg_FormattedTableMerged *|struct _dwg_FormattedTableMerged *|_dwg_FormattedTableMerged *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_GEODATA_meshface = {"_p__dwg_GEODATA_meshface", "Dwg_GEODATA_meshface *|struct _dwg_GEODATA_meshface *|_dwg_GEODATA_meshface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_GEODATA_meshpt = {"_p__dwg_GEODATA_meshpt", "Dwg_GEODATA_meshpt *|struct _dwg_GEODATA_meshpt *|_dwg_GEODATA_meshpt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_GridFormat = {"_p__dwg_GridFormat", "Dwg_GridFormat *|struct _dwg_GridFormat *|_dwg_GridFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_Color = {"_p__dwg_HATCH_Color", "Dwg_HATCH_Color *|struct _dwg_HATCH_Color *|_dwg_HATCH_Color *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_ControlPoint = {"_p__dwg_HATCH_ControlPoint", "Dwg_HATCH_ControlPoint *|struct _dwg_HATCH_ControlPoint *|_dwg_HATCH_ControlPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_DefLine = {"_p__dwg_HATCH_DefLine", "Dwg_HATCH_DefLine *|struct _dwg_HATCH_DefLine *|_dwg_HATCH_DefLine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_Path = {"_p__dwg_HATCH_Path", "Dwg_HATCH_Path *|struct _dwg_HATCH_Path *|_dwg_HATCH_Path *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_PathSeg = {"_p__dwg_HATCH_PathSeg", "Dwg_HATCH_PathSeg *|struct _dwg_HATCH_PathSeg *|_dwg_HATCH_PathSeg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_HATCH_PolylinePath = {"_p__dwg_HATCH_PolylinePath", "Dwg_HATCH_PolylinePath *|struct _dwg_HATCH_PolylinePath *|_dwg_HATCH_PolylinePath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LAYER_entry = {"_p__dwg_LAYER_entry", "Dwg_LAYER_entry *|struct _dwg_LAYER_entry *|_dwg_LAYER_entry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LEADER_ArrowHead = {"_p__dwg_LEADER_ArrowHead", "Dwg_LEADER_ArrowHead *|struct _dwg_LEADER_ArrowHead *|_dwg_LEADER_ArrowHead *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LEADER_BlockLabel = {"_p__dwg_LEADER_BlockLabel", "Dwg_LEADER_BlockLabel *|struct _dwg_LEADER_BlockLabel *|_dwg_LEADER_BlockLabel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LEADER_Break = {"_p__dwg_LEADER_Break", "Dwg_LEADER_Break *|struct _dwg_LEADER_Break *|_dwg_LEADER_Break *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LEADER_Line = {"_p__dwg_LEADER_Line", "Dwg_LEADER_Line *|struct _dwg_LEADER_Line *|_dwg_LEADER_Line *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LEADER_Node = {"_p__dwg_LEADER_Node", "Dwg_LEADER_Node *|struct _dwg_LEADER_Node *|_dwg_LEADER_Node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LIGHTLIST_light = {"_p__dwg_LIGHTLIST_light", "Dwg_LIGHTLIST_light *|struct _dwg_LIGHTLIST_light *|_dwg_LIGHTLIST_light *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LTYPE_dash = {"_p__dwg_LTYPE_dash", "Dwg_LTYPE_dash *|struct _dwg_LTYPE_dash *|_dwg_LTYPE_dash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LWPOLYLINE_width = {"_p__dwg_LWPOLYLINE_width", "Dwg_LWPOLYLINE_width *|struct _dwg_LWPOLYLINE_width *|_dwg_LWPOLYLINE_width *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LinkedData = {"_p__dwg_LinkedData", "Dwg_LinkedData *|struct _dwg_LinkedData *|_dwg_LinkedData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_LinkedTableData = {"_p__dwg_LinkedTableData", "Dwg_LinkedTableData *|struct _dwg_LinkedTableData *|_dwg_LinkedTableData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MATERIAL_color = {"_p__dwg_MATERIAL_color", "Dwg_MATERIAL_color *|struct _dwg_MATERIAL_color *|_dwg_MATERIAL_color *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MATERIAL_gentexture = {"_p__dwg_MATERIAL_gentexture", "Dwg_MATERIAL_gentexture *|struct _dwg_MATERIAL_gentexture *|_dwg_MATERIAL_gentexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MATERIAL_mapper = {"_p__dwg_MATERIAL_mapper", "Dwg_MATERIAL_mapper *|struct _dwg_MATERIAL_mapper *|_dwg_MATERIAL_mapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MESH_edge = {"_p__dwg_MESH_edge", "Dwg_MESH_edge *|struct _dwg_MESH_edge *|_dwg_MESH_edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLEADER_AnnotContext = {"_p__dwg_MLEADER_AnnotContext", "Dwg_MLEADER_AnnotContext *|struct _dwg_MLEADER_AnnotContext *|_dwg_MLEADER_AnnotContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLEADER_Content = {"_p__dwg_MLEADER_Content", "Dwg_MLEADER_Content *|union _dwg_MLEADER_Content *|_dwg_MLEADER_Content *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLEADER_Content_Block = {"_p__dwg_MLEADER_Content_Block", "Dwg_MLEADER_Content_Block *|struct _dwg_MLEADER_Content_Block *|_dwg_MLEADER_Content_Block *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLEADER_Content_MText = {"_p__dwg_MLEADER_Content_MText", "Dwg_MLEADER_Content_MText *|struct _dwg_MLEADER_Content_MText *|_dwg_MLEADER_Content_MText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLINESTYLE_line = {"_p__dwg_MLINESTYLE_line", "Dwg_MLINESTYLE_line *|struct _dwg_MLINESTYLE_line *|_dwg_MLINESTYLE_line *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLINESTYLE_line_lt = {"_p__dwg_MLINESTYLE_line_lt", "_dwg_MLINESTYLE_line_lt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLINE_line = {"_p__dwg_MLINE_line", "Dwg_MLINE_line *|struct _dwg_MLINE_line *|_dwg_MLINE_line *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_MLINE_vertex = {"_p__dwg_MLINE_vertex", "Dwg_MLINE_vertex *|struct _dwg_MLINE_vertex *|_dwg_MLINE_vertex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_OCD_Dimension = {"_p__dwg_OCD_Dimension", "Dwg_OCD_Dimension *|struct _dwg_OCD_Dimension *|_dwg_OCD_Dimension *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_PARTIAL_VIEWING_INDEX_Entry = {"_p__dwg_PARTIAL_VIEWING_INDEX_Entry", "Dwg_PARTIAL_VIEWING_INDEX_Entry *|struct _dwg_PARTIAL_VIEWING_INDEX_Entry *|_dwg_PARTIAL_VIEWING_INDEX_Entry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_POINTCLOUDCOLORMAP_Ramp = {"_p__dwg_POINTCLOUDCOLORMAP_Ramp", "Dwg_POINTCLOUDCOLORMAP_Ramp *|struct _dwg_POINTCLOUDCOLORMAP_Ramp *|_dwg_POINTCLOUDCOLORMAP_Ramp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_POINTCLOUDEX_Croppings = {"_p__dwg_POINTCLOUDEX_Croppings", "Dwg_POINTCLOUDEX_Croppings *|struct _dwg_POINTCLOUDEX_Croppings *|_dwg_POINTCLOUDEX_Croppings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_POINTCLOUD_Clippings = {"_p__dwg_POINTCLOUD_Clippings", "Dwg_POINTCLOUD_Clippings *|struct _dwg_POINTCLOUD_Clippings *|_dwg_POINTCLOUD_Clippings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_POINTCLOUD_IntensityStyle = {"_p__dwg_POINTCLOUD_IntensityStyle", "Dwg_POINTCLOUD_IntensityStyle *|struct _dwg_POINTCLOUD_IntensityStyle *|_dwg_POINTCLOUD_IntensityStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_PROXY_LWPOLYLINE = {"_p__dwg_PROXY_LWPOLYLINE", "Dwg_PROXY_LWPOLYLINE *|struct _dwg_PROXY_LWPOLYLINE *|_dwg_PROXY_LWPOLYLINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_R2004_Header = {"_p__dwg_R2004_Header", "Dwg_R2004_Header *|struct _dwg_R2004_Header *|_dwg_R2004_Header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_SECTION_geometrysettings = {"_p__dwg_SECTION_geometrysettings", "Dwg_SECTION_geometrysettings *|struct _dwg_SECTION_geometrysettings *|_dwg_SECTION_geometrysettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_SECTION_typesettings = {"_p__dwg_SECTION_typesettings", "Dwg_SECTION_typesettings *|struct _dwg_SECTION_typesettings *|_dwg_SECTION_typesettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_SPLINE_control_point = {"_p__dwg_SPLINE_control_point", "Dwg_SPLINE_control_point *|struct _dwg_SPLINE_control_point *|_dwg_SPLINE_control_point *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_SUNSTUDY_Dates = {"_p__dwg_SUNSTUDY_Dates", "Dwg_SUNSTUDY_Dates *|struct _dwg_SUNSTUDY_Dates *|_dwg_SUNSTUDY_Dates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_SummaryInfo_Property = {"_p__dwg_SummaryInfo_Property", "Dwg_SummaryInfo_Property *|struct _dwg_SummaryInfo_Property *|_dwg_SummaryInfo_Property *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLEGEOMETRY_Cell = {"_p__dwg_TABLEGEOMETRY_Cell", "Dwg_TABLEGEOMETRY_Cell *|struct _dwg_TABLEGEOMETRY_Cell *|_dwg_TABLEGEOMETRY_Cell *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLESTYLE_CellStyle = {"_p__dwg_TABLESTYLE_CellStyle", "Dwg_TABLESTYLE_CellStyle *|struct _dwg_TABLESTYLE_CellStyle *|_dwg_TABLESTYLE_CellStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLESTYLE_border = {"_p__dwg_TABLESTYLE_border", "Dwg_TABLESTYLE_border *|struct _dwg_TABLESTYLE_border *|_dwg_TABLESTYLE_border *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLESTYLE_rowstyles = {"_p__dwg_TABLESTYLE_rowstyles", "Dwg_TABLESTYLE_rowstyles *|struct _dwg_TABLESTYLE_rowstyles *|_dwg_TABLESTYLE_rowstyles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_AttrDef = {"_p__dwg_TABLE_AttrDef", "Dwg_TABLE_AttrDef *|struct _dwg_TABLE_AttrDef *|_dwg_TABLE_AttrDef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_BreakHeight = {"_p__dwg_TABLE_BreakHeight", "Dwg_TABLE_BreakHeight *|struct _dwg_TABLE_BreakHeight *|_dwg_TABLE_BreakHeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_BreakRow = {"_p__dwg_TABLE_BreakRow", "Dwg_TABLE_BreakRow *|struct _dwg_TABLE_BreakRow *|_dwg_TABLE_BreakRow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_Cell = {"_p__dwg_TABLE_Cell", "Dwg_TABLE_Cell *|struct _dwg_TABLE_Cell *|_dwg_TABLE_Cell *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_CustomDataItem = {"_p__dwg_TABLE_CustomDataItem", "Dwg_TABLE_CustomDataItem *|struct _dwg_TABLE_CustomDataItem *|_dwg_TABLE_CustomDataItem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TABLE_value = {"_p__dwg_TABLE_value", "Dwg_TABLE_value *|struct _dwg_TABLE_value *|_dwg_TABLE_value *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TableCell = {"_p__dwg_TableCell", "Dwg_TableCell *|struct _dwg_TableCell *|_dwg_TableCell *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TableCellContent = {"_p__dwg_TableCellContent", "Dwg_TableCellContent *|struct _dwg_TableCellContent *|_dwg_TableCellContent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TableCellContent_Attr = {"_p__dwg_TableCellContent_Attr", "Dwg_TableCellContent_Attr *|struct _dwg_TableCellContent_Attr *|_dwg_TableCellContent_Attr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TableDataColumn = {"_p__dwg_TableDataColumn", "Dwg_TableDataColumn *|struct _dwg_TableDataColumn *|_dwg_TableDataColumn *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_TableRow = {"_p__dwg_TableRow", "Dwg_TableRow *|struct _dwg_TableRow *|_dwg_TableRow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_UCS_orthopts = {"_p__dwg_UCS_orthopts", "Dwg_UCS_orthopts *|struct _dwg_UCS_orthopts *|_dwg_UCS_orthopts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_VALUEPARAM = {"_p__dwg_VALUEPARAM", "Dwg_VALUEPARAM *|struct _dwg_VALUEPARAM *|_dwg_VALUEPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_VALUEPARAM_vars = {"_p__dwg_VALUEPARAM_vars", "Dwg_VALUEPARAM_vars *|struct _dwg_VALUEPARAM_vars *|_dwg_VALUEPARAM_vars *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_abstractentity_UNDERLAY = {"_p__dwg_abstractentity_UNDERLAY", "Dwg_Entity_DGNUNDERLAY *|Dwg_Entity_DWFUNDERLAY *|Dwg_Entity_PDFUNDERLAY *|Dwg_Entity_UNDERLAY *|struct _dwg_abstractentity_UNDERLAY *|_dwg_abstractentity_UNDERLAY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_abstractobject_ASSOCARRAYPARAMETERS = {"_p__dwg_abstractobject_ASSOCARRAYPARAMETERS", "Dwg_Object_ASSOCARRAYMODIFYPARAMETERS *|Dwg_Object_ASSOCARRAYPARAMETERS *|Dwg_Object_ASSOCARRAYPATHPARAMETERS *|Dwg_Object_ASSOCARRAYPOLARPARAMETERS *|Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS *|struct _dwg_abstractobject_ASSOCARRAYPARAMETERS *|_dwg_abstractobject_ASSOCARRAYPARAMETERS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_abstractobject_UNDERLAYDEFINITION = {"_p__dwg_abstractobject_UNDERLAYDEFINITION", "Dwg_Object_DGNDEFINITION *|Dwg_Object_DWFDEFINITION *|Dwg_Object_PDFDEFINITION *|Dwg_Object_UNDERLAYDEFINITION *|struct _dwg_abstractobject_UNDERLAYDEFINITION *|_dwg_abstractobject_UNDERLAYDEFINITION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_appinfo = {"_p__dwg_appinfo", "Dwg_AppInfo *|struct _dwg_appinfo *|_dwg_appinfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_appinfohistory = {"_p__dwg_appinfohistory", "Dwg_AppInfoHistory *|struct _dwg_appinfohistory *|_dwg_appinfohistory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_auxheader = {"_p__dwg_auxheader", "Dwg_AuxHeader *|struct _dwg_auxheader *|_dwg_auxheader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_binary_chunk = {"_p__dwg_binary_chunk", "struct _dwg_binary_chunk *|_dwg_binary_chunk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_binary_chunk_u = {"_p__dwg_binary_chunk_u", "_dwg_binary_chunk_u *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_bitcode_2bd = {"_p__dwg_bitcode_2bd", "BITCODE_2BD *|BITCODE_2BD_1 *|BITCODE_2DPOINT *|Dwg_Bitcode_2BD *|struct _dwg_bitcode_2bd *|_dwg_bitcode_2bd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_bitcode_2rd = {"_p__dwg_bitcode_2rd", "BITCODE_2RD *|Dwg_Bitcode_2RD *|struct _dwg_bitcode_2rd *|_dwg_bitcode_2rd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_bitcode_3bd = {"_p__dwg_bitcode_3bd", "BITCODE_3BD *|BITCODE_3BD_1 *|BITCODE_3DPOINT *|BITCODE_BE *|Dwg_Bitcode_3BD *|struct _dwg_bitcode_3bd *|_dwg_bitcode_3bd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_bitcode_3rd = {"_p__dwg_bitcode_3rd", "BITCODE_3RD *|Dwg_Bitcode_3RD *|struct _dwg_bitcode_3rd *|_dwg_bitcode_3rd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_chain = {"_p__dwg_chain", "Dwg_Chain *|struct _dwg_chain *|_dwg_chain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_class = {"_p__dwg_class", "Dwg_Class *|struct _dwg_class *|_dwg_class *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_color = {"_p__dwg_color", "BITCODE_CMC *|BITCODE_CMTC *|BITCODE_ENC *|Dwg_Color *|struct _dwg_color *|_dwg_color *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_3DFACE = {"_p__dwg_entity_3DFACE", "Dwg_Entity__3DFACE *|struct _dwg_entity_3DFACE *|_dwg_entity_3DFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_3DLINE = {"_p__dwg_entity_3DLINE", "Dwg_Entity__3DLINE *|struct _dwg_entity_3DLINE *|_dwg_entity_3DLINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_3DSOLID = {"_p__dwg_entity_3DSOLID", "Dwg_Entity_BODY *|Dwg_Entity_REGION *|Dwg_Entity__3DSOLID *|struct _dwg_entity_3DSOLID *|_dwg_entity_3DSOLID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ALIGNMENTPARAMETERENTITY = {"_p__dwg_entity_ALIGNMENTPARAMETERENTITY", "Dwg_Entity_ALIGNMENTPARAMETERENTITY *|struct _dwg_entity_ALIGNMENTPARAMETERENTITY *|_dwg_entity_ALIGNMENTPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ARC = {"_p__dwg_entity_ARC", "Dwg_Entity_ARC *|struct _dwg_entity_ARC *|_dwg_entity_ARC *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ARCALIGNEDTEXT = {"_p__dwg_entity_ARCALIGNEDTEXT", "Dwg_Entity_ARCALIGNEDTEXT *|struct _dwg_entity_ARCALIGNEDTEXT *|_dwg_entity_ARCALIGNEDTEXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ARC_DIMENSION = {"_p__dwg_entity_ARC_DIMENSION", "Dwg_Entity_ARC_DIMENSION *|struct _dwg_entity_ARC_DIMENSION *|_dwg_entity_ARC_DIMENSION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ATTDEF = {"_p__dwg_entity_ATTDEF", "Dwg_Entity_ATTDEF *|struct _dwg_entity_ATTDEF *|_dwg_entity_ATTDEF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ATTRIB = {"_p__dwg_entity_ATTRIB", "Dwg_Entity_ATTRIB *|struct _dwg_entity_ATTRIB *|_dwg_entity_ATTRIB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_BASEPOINTPARAMETERENTITY = {"_p__dwg_entity_BASEPOINTPARAMETERENTITY", "Dwg_Entity_BASEPOINTPARAMETERENTITY *|struct _dwg_entity_BASEPOINTPARAMETERENTITY *|_dwg_entity_BASEPOINTPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_BLOCK = {"_p__dwg_entity_BLOCK", "Dwg_Entity_BLOCK *|struct _dwg_entity_BLOCK *|_dwg_entity_BLOCK *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_CAMERA = {"_p__dwg_entity_CAMERA", "Dwg_Entity_CAMERA *|struct _dwg_entity_CAMERA *|_dwg_entity_CAMERA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_CIRCLE = {"_p__dwg_entity_CIRCLE", "Dwg_Entity_CIRCLE *|struct _dwg_entity_CIRCLE *|_dwg_entity_CIRCLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_ALIGNED = {"_p__dwg_entity_DIMENSION_ALIGNED", "Dwg_Entity_DIMENSION_ALIGNED *|struct _dwg_entity_DIMENSION_ALIGNED *|_dwg_entity_DIMENSION_ALIGNED *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_ANG2LN = {"_p__dwg_entity_DIMENSION_ANG2LN", "Dwg_Entity_DIMENSION_ANG2LN *|struct _dwg_entity_DIMENSION_ANG2LN *|_dwg_entity_DIMENSION_ANG2LN *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_ANG3PT = {"_p__dwg_entity_DIMENSION_ANG3PT", "Dwg_Entity_DIMENSION_ANG3PT *|struct _dwg_entity_DIMENSION_ANG3PT *|_dwg_entity_DIMENSION_ANG3PT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_DIAMETER = {"_p__dwg_entity_DIMENSION_DIAMETER", "Dwg_Entity_DIMENSION_DIAMETER *|struct _dwg_entity_DIMENSION_DIAMETER *|_dwg_entity_DIMENSION_DIAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_LINEAR = {"_p__dwg_entity_DIMENSION_LINEAR", "Dwg_Entity_DIMENSION_LINEAR *|struct _dwg_entity_DIMENSION_LINEAR *|_dwg_entity_DIMENSION_LINEAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_ORDINATE = {"_p__dwg_entity_DIMENSION_ORDINATE", "Dwg_Entity_DIMENSION_ORDINATE *|struct _dwg_entity_DIMENSION_ORDINATE *|_dwg_entity_DIMENSION_ORDINATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_DIMENSION_RADIUS = {"_p__dwg_entity_DIMENSION_RADIUS", "Dwg_Entity_DIMENSION_RADIUS *|struct _dwg_entity_DIMENSION_RADIUS *|_dwg_entity_DIMENSION_RADIUS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ELLIPSE = {"_p__dwg_entity_ELLIPSE", "Dwg_Entity_ELLIPSE *|struct _dwg_entity_ELLIPSE *|_dwg_entity_ELLIPSE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ENDBLK = {"_p__dwg_entity_ENDBLK", "Dwg_Entity_ENDBLK *|struct _dwg_entity_ENDBLK *|_dwg_entity_ENDBLK *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ENDREP = {"_p__dwg_entity_ENDREP", "Dwg_Entity_ENDREP *|struct _dwg_entity_ENDREP *|_dwg_entity_ENDREP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_EXTRUDEDSURFACE = {"_p__dwg_entity_EXTRUDEDSURFACE", "Dwg_Entity_EXTRUDEDSURFACE *|struct _dwg_entity_EXTRUDEDSURFACE *|_dwg_entity_EXTRUDEDSURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_FLIPGRIPENTITY = {"_p__dwg_entity_FLIPGRIPENTITY", "Dwg_Entity_FLIPGRIPENTITY *|struct _dwg_entity_FLIPGRIPENTITY *|_dwg_entity_FLIPGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_FLIPPARAMETERENTITY = {"_p__dwg_entity_FLIPPARAMETERENTITY", "Dwg_Entity_FLIPPARAMETERENTITY *|struct _dwg_entity_FLIPPARAMETERENTITY *|_dwg_entity_FLIPPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_GEOPOSITIONMARKER = {"_p__dwg_entity_GEOPOSITIONMARKER", "Dwg_Entity_GEOPOSITIONMARKER *|struct _dwg_entity_GEOPOSITIONMARKER *|_dwg_entity_GEOPOSITIONMARKER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_HATCH = {"_p__dwg_entity_HATCH", "Dwg_Entity_HATCH *|struct _dwg_entity_HATCH *|_dwg_entity_HATCH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_HELIX = {"_p__dwg_entity_HELIX", "Dwg_Entity_HELIX *|struct _dwg_entity_HELIX *|_dwg_entity_HELIX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_IMAGE = {"_p__dwg_entity_IMAGE", "Dwg_Entity_IMAGE *|struct _dwg_entity_IMAGE *|_dwg_entity_IMAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_INSERT = {"_p__dwg_entity_INSERT", "Dwg_Entity_INSERT *|struct _dwg_entity_INSERT *|_dwg_entity_INSERT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_JUMP = {"_p__dwg_entity_JUMP", "Dwg_Entity_JUMP *|struct _dwg_entity_JUMP *|_dwg_entity_JUMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LARGE_RADIAL_DIMENSION = {"_p__dwg_entity_LARGE_RADIAL_DIMENSION", "Dwg_Entity_LARGE_RADIAL_DIMENSION *|struct _dwg_entity_LARGE_RADIAL_DIMENSION *|_dwg_entity_LARGE_RADIAL_DIMENSION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LAYOUTPRINTCONFIG = {"_p__dwg_entity_LAYOUTPRINTCONFIG", "Dwg_Entity_LAYOUTPRINTCONFIG *|struct _dwg_entity_LAYOUTPRINTCONFIG *|_dwg_entity_LAYOUTPRINTCONFIG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LEADER = {"_p__dwg_entity_LEADER", "Dwg_Entity_LEADER *|struct _dwg_entity_LEADER *|_dwg_entity_LEADER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LIGHT = {"_p__dwg_entity_LIGHT", "Dwg_Entity_LIGHT *|struct _dwg_entity_LIGHT *|_dwg_entity_LIGHT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LINE = {"_p__dwg_entity_LINE", "Dwg_Entity_LINE *|struct _dwg_entity_LINE *|_dwg_entity_LINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LINEARGRIPENTITY = {"_p__dwg_entity_LINEARGRIPENTITY", "Dwg_Entity_LINEARGRIPENTITY *|struct _dwg_entity_LINEARGRIPENTITY *|_dwg_entity_LINEARGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LINEARPARAMETERENTITY = {"_p__dwg_entity_LINEARPARAMETERENTITY", "Dwg_Entity_LINEARPARAMETERENTITY *|struct _dwg_entity_LINEARPARAMETERENTITY *|_dwg_entity_LINEARPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LOAD = {"_p__dwg_entity_LOAD", "Dwg_Entity_LOAD *|struct _dwg_entity_LOAD *|_dwg_entity_LOAD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LOFTEDSURFACE = {"_p__dwg_entity_LOFTEDSURFACE", "Dwg_Entity_LOFTEDSURFACE *|struct _dwg_entity_LOFTEDSURFACE *|_dwg_entity_LOFTEDSURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_LWPOLYLINE = {"_p__dwg_entity_LWPOLYLINE", "Dwg_Entity_LWPOLYLINE *|struct _dwg_entity_LWPOLYLINE *|_dwg_entity_LWPOLYLINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MESH = {"_p__dwg_entity_MESH", "Dwg_Entity_MESH *|struct _dwg_entity_MESH *|_dwg_entity_MESH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MINSERT = {"_p__dwg_entity_MINSERT", "Dwg_Entity_MINSERT *|struct _dwg_entity_MINSERT *|_dwg_entity_MINSERT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MLINE = {"_p__dwg_entity_MLINE", "Dwg_Entity_MLINE *|struct _dwg_entity_MLINE *|_dwg_entity_MLINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MPOLYGON = {"_p__dwg_entity_MPOLYGON", "Dwg_Entity_MPOLYGON *|struct _dwg_entity_MPOLYGON *|_dwg_entity_MPOLYGON *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MTEXT = {"_p__dwg_entity_MTEXT", "Dwg_Entity_MTEXT *|struct _dwg_entity_MTEXT *|_dwg_entity_MTEXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_MULTILEADER = {"_p__dwg_entity_MULTILEADER", "Dwg_Entity_MULTILEADER *|struct _dwg_entity_MULTILEADER *|_dwg_entity_MULTILEADER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_NAVISWORKSMODEL = {"_p__dwg_entity_NAVISWORKSMODEL", "Dwg_Entity_NAVISWORKSMODEL *|struct _dwg_entity_NAVISWORKSMODEL *|_dwg_entity_NAVISWORKSMODEL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_NURBSURFACE = {"_p__dwg_entity_NURBSURFACE", "Dwg_Entity_NURBSURFACE *|struct _dwg_entity_NURBSURFACE *|_dwg_entity_NURBSURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_OLE2FRAME = {"_p__dwg_entity_OLE2FRAME", "Dwg_Entity_OLE2FRAME *|struct _dwg_entity_OLE2FRAME *|_dwg_entity_OLE2FRAME *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_OLEFRAME = {"_p__dwg_entity_OLEFRAME", "Dwg_Entity_OLEFRAME *|struct _dwg_entity_OLEFRAME *|_dwg_entity_OLEFRAME *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_PLANESURFACE = {"_p__dwg_entity_PLANESURFACE", "Dwg_Entity_PLANESURFACE *|struct _dwg_entity_PLANESURFACE *|_dwg_entity_PLANESURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POINT = {"_p__dwg_entity_POINT", "Dwg_Entity_POINT *|struct _dwg_entity_POINT *|_dwg_entity_POINT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POINTCLOUD = {"_p__dwg_entity_POINTCLOUD", "Dwg_Entity_POINTCLOUD *|struct _dwg_entity_POINTCLOUD *|_dwg_entity_POINTCLOUD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POINTCLOUDEX = {"_p__dwg_entity_POINTCLOUDEX", "Dwg_Entity_POINTCLOUDEX *|struct _dwg_entity_POINTCLOUDEX *|_dwg_entity_POINTCLOUDEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POINTPARAMETERENTITY = {"_p__dwg_entity_POINTPARAMETERENTITY", "Dwg_Entity_POINTPARAMETERENTITY *|struct _dwg_entity_POINTPARAMETERENTITY *|_dwg_entity_POINTPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POLARGRIPENTITY = {"_p__dwg_entity_POLARGRIPENTITY", "Dwg_Entity_POLARGRIPENTITY *|struct _dwg_entity_POLARGRIPENTITY *|_dwg_entity_POLARGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POLYLINE_2D = {"_p__dwg_entity_POLYLINE_2D", "Dwg_Entity_POLYLINE_2D *|struct _dwg_entity_POLYLINE_2D *|_dwg_entity_POLYLINE_2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POLYLINE_3D = {"_p__dwg_entity_POLYLINE_3D", "Dwg_Entity_POLYLINE_3D *|struct _dwg_entity_POLYLINE_3D *|_dwg_entity_POLYLINE_3D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POLYLINE_MESH = {"_p__dwg_entity_POLYLINE_MESH", "Dwg_Entity_POLYLINE_MESH *|struct _dwg_entity_POLYLINE_MESH *|_dwg_entity_POLYLINE_MESH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_POLYLINE_PFACE = {"_p__dwg_entity_POLYLINE_PFACE", "Dwg_Entity_POLYLINE_PFACE *|struct _dwg_entity_POLYLINE_PFACE *|_dwg_entity_POLYLINE_PFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_PROXY_ENTITY = {"_p__dwg_entity_PROXY_ENTITY", "Dwg_Entity_PROXY_ENTITY *|struct _dwg_entity_PROXY_ENTITY *|_dwg_entity_PROXY_ENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_RAY = {"_p__dwg_entity_RAY", "Dwg_Entity_RAY *|Dwg_Entity_XLINE *|struct _dwg_entity_RAY *|_dwg_entity_RAY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_REPEAT = {"_p__dwg_entity_REPEAT", "Dwg_Entity_REPEAT *|struct _dwg_entity_REPEAT *|_dwg_entity_REPEAT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_REVOLVEDSURFACE = {"_p__dwg_entity_REVOLVEDSURFACE", "Dwg_Entity_REVOLVEDSURFACE *|struct _dwg_entity_REVOLVEDSURFACE *|_dwg_entity_REVOLVEDSURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ROTATIONGRIPENTITY = {"_p__dwg_entity_ROTATIONGRIPENTITY", "Dwg_Entity_ROTATIONGRIPENTITY *|struct _dwg_entity_ROTATIONGRIPENTITY *|_dwg_entity_ROTATIONGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_ROTATIONPARAMETERENTITY = {"_p__dwg_entity_ROTATIONPARAMETERENTITY", "Dwg_Entity_ROTATIONPARAMETERENTITY *|struct _dwg_entity_ROTATIONPARAMETERENTITY *|_dwg_entity_ROTATIONPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_RTEXT = {"_p__dwg_entity_RTEXT", "Dwg_Entity_RTEXT *|struct _dwg_entity_RTEXT *|_dwg_entity_RTEXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SECTIONOBJECT = {"_p__dwg_entity_SECTIONOBJECT", "Dwg_Entity_SECTIONOBJECT *|struct _dwg_entity_SECTIONOBJECT *|_dwg_entity_SECTIONOBJECT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SEQEND = {"_p__dwg_entity_SEQEND", "Dwg_Entity_SEQEND *|struct _dwg_entity_SEQEND *|_dwg_entity_SEQEND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SHAPE = {"_p__dwg_entity_SHAPE", "Dwg_Entity_SHAPE *|struct _dwg_entity_SHAPE *|_dwg_entity_SHAPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SOLID = {"_p__dwg_entity_SOLID", "Dwg_Entity_SOLID *|struct _dwg_entity_SOLID *|_dwg_entity_SOLID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SPLINE = {"_p__dwg_entity_SPLINE", "Dwg_Entity_SPLINE *|struct _dwg_entity_SPLINE *|_dwg_entity_SPLINE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_SWEPTSURFACE = {"_p__dwg_entity_SWEPTSURFACE", "Dwg_Entity_SWEPTSURFACE *|struct _dwg_entity_SWEPTSURFACE *|_dwg_entity_SWEPTSURFACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_TABLE = {"_p__dwg_entity_TABLE", "Dwg_Entity_TABLE *|struct _dwg_entity_TABLE *|_dwg_entity_TABLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_TEXT = {"_p__dwg_entity_TEXT", "Dwg_Entity_TEXT *|struct _dwg_entity_TEXT *|_dwg_entity_TEXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_TOLERANCE = {"_p__dwg_entity_TOLERANCE", "Dwg_Entity_TOLERANCE *|struct _dwg_entity_TOLERANCE *|_dwg_entity_TOLERANCE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_TRACE = {"_p__dwg_entity_TRACE", "Dwg_Entity_TRACE *|struct _dwg_entity_TRACE *|_dwg_entity_TRACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_UNKNOWN_ENT = {"_p__dwg_entity_UNKNOWN_ENT", "Dwg_Entity_UNKNOWN_ENT *|struct _dwg_entity_UNKNOWN_ENT *|_dwg_entity_UNKNOWN_ENT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VERTEX_2D = {"_p__dwg_entity_VERTEX_2D", "Dwg_Entity_VERTEX_2D *|struct _dwg_entity_VERTEX_2D *|_dwg_entity_VERTEX_2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VERTEX_3D = {"_p__dwg_entity_VERTEX_3D", "Dwg_Entity_VERTEX_3D *|Dwg_Entity_VERTEX_MESH *|Dwg_Entity_VERTEX_PFACE *|struct _dwg_entity_VERTEX_3D *|_dwg_entity_VERTEX_3D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VERTEX_PFACE_FACE = {"_p__dwg_entity_VERTEX_PFACE_FACE", "Dwg_Entity_VERTEX_PFACE_FACE *|struct _dwg_entity_VERTEX_PFACE_FACE *|_dwg_entity_VERTEX_PFACE_FACE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VIEWPORT = {"_p__dwg_entity_VIEWPORT", "Dwg_Entity_VIEWPORT *|struct _dwg_entity_VIEWPORT *|_dwg_entity_VIEWPORT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VISIBILITYGRIPENTITY = {"_p__dwg_entity_VISIBILITYGRIPENTITY", "Dwg_Entity_VISIBILITYGRIPENTITY *|struct _dwg_entity_VISIBILITYGRIPENTITY *|_dwg_entity_VISIBILITYGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_VISIBILITYPARAMETERENTITY = {"_p__dwg_entity_VISIBILITYPARAMETERENTITY", "Dwg_Entity_VISIBILITYPARAMETERENTITY *|struct _dwg_entity_VISIBILITYPARAMETERENTITY *|_dwg_entity_VISIBILITYPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_WIPEOUT = {"_p__dwg_entity_WIPEOUT", "Dwg_Entity_WIPEOUT *|struct _dwg_entity_WIPEOUT *|_dwg_entity_WIPEOUT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_XYGRIPENTITY = {"_p__dwg_entity_XYGRIPENTITY", "Dwg_Entity_XYGRIPENTITY *|struct _dwg_entity_XYGRIPENTITY *|_dwg_entity_XYGRIPENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_XYPARAMETERENTITY = {"_p__dwg_entity_XYPARAMETERENTITY", "Dwg_Entity_XYPARAMETERENTITY *|struct _dwg_entity_XYPARAMETERENTITY *|_dwg_entity_XYPARAMETERENTITY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_eed = {"_p__dwg_entity_eed", "Dwg_Eed *|struct _dwg_entity_eed *|_dwg_entity_eed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_entity_eed_data = {"_p__dwg_entity_eed_data", "Dwg_Eed_Data *|struct _dwg_entity_eed_data *|_dwg_entity_eed_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_filedeplist = {"_p__dwg_filedeplist", "Dwg_FileDepList *|struct _dwg_filedeplist *|_dwg_filedeplist *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_handle = {"_p__dwg_handle", "Dwg_Handle *|struct _dwg_handle *|_dwg_handle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_header = {"_p__dwg_header", "Dwg_Header *|struct _dwg_header *|_dwg_header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_header_variables = {"_p__dwg_header_variables", "Dwg_Header_Variables *|struct _dwg_header_variables *|_dwg_header_variables *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object = {"_p__dwg_object", "Dwg_Object *|struct _dwg_object *|_dwg_object *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACMECOMMANDHISTORY = {"_p__dwg_object_ACMECOMMANDHISTORY", "Dwg_Object_ACMECOMMANDHISTORY *|struct _dwg_object_ACMECOMMANDHISTORY *|_dwg_object_ACMECOMMANDHISTORY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACMESCOPE = {"_p__dwg_object_ACMESCOPE", "Dwg_Object_ACMESCOPE *|struct _dwg_object_ACMESCOPE *|_dwg_object_ACMESCOPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACMESTATEMGR = {"_p__dwg_object_ACMESTATEMGR", "Dwg_Object_ACMESTATEMGR *|struct _dwg_object_ACMESTATEMGR *|_dwg_object_ACMESTATEMGR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_BOOLEAN_CLASS = {"_p__dwg_object_ACSH_BOOLEAN_CLASS", "Dwg_Object_ACSH_BOOLEAN_CLASS *|struct _dwg_object_ACSH_BOOLEAN_CLASS *|_dwg_object_ACSH_BOOLEAN_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_BOX_CLASS = {"_p__dwg_object_ACSH_BOX_CLASS", "Dwg_Object_ACSH_BOX_CLASS *|struct _dwg_object_ACSH_BOX_CLASS *|_dwg_object_ACSH_BOX_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_BREP_CLASS = {"_p__dwg_object_ACSH_BREP_CLASS", "Dwg_Object_ACSH_BREP_CLASS *|struct _dwg_object_ACSH_BREP_CLASS *|_dwg_object_ACSH_BREP_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_CHAMFER_CLASS = {"_p__dwg_object_ACSH_CHAMFER_CLASS", "Dwg_Object_ACSH_CHAMFER_CLASS *|struct _dwg_object_ACSH_CHAMFER_CLASS *|_dwg_object_ACSH_CHAMFER_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_CONE_CLASS = {"_p__dwg_object_ACSH_CONE_CLASS", "Dwg_Object_ACSH_CONE_CLASS *|struct _dwg_object_ACSH_CONE_CLASS *|_dwg_object_ACSH_CONE_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_CYLINDER_CLASS = {"_p__dwg_object_ACSH_CYLINDER_CLASS", "Dwg_Object_ACSH_CYLINDER_CLASS *|struct _dwg_object_ACSH_CYLINDER_CLASS *|_dwg_object_ACSH_CYLINDER_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_EXTRUSION_CLASS = {"_p__dwg_object_ACSH_EXTRUSION_CLASS", "Dwg_Object_ACSH_EXTRUSION_CLASS *|struct _dwg_object_ACSH_EXTRUSION_CLASS *|_dwg_object_ACSH_EXTRUSION_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_FILLET_CLASS = {"_p__dwg_object_ACSH_FILLET_CLASS", "Dwg_Object_ACSH_FILLET_CLASS *|struct _dwg_object_ACSH_FILLET_CLASS *|_dwg_object_ACSH_FILLET_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_HISTORY_CLASS = {"_p__dwg_object_ACSH_HISTORY_CLASS", "Dwg_Object_ACSH_HISTORY_CLASS *|struct _dwg_object_ACSH_HISTORY_CLASS *|_dwg_object_ACSH_HISTORY_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_LOFT_CLASS = {"_p__dwg_object_ACSH_LOFT_CLASS", "Dwg_Object_ACSH_LOFT_CLASS *|struct _dwg_object_ACSH_LOFT_CLASS *|_dwg_object_ACSH_LOFT_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_PYRAMID_CLASS = {"_p__dwg_object_ACSH_PYRAMID_CLASS", "Dwg_Object_ACSH_PYRAMID_CLASS *|struct _dwg_object_ACSH_PYRAMID_CLASS *|_dwg_object_ACSH_PYRAMID_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_REVOLVE_CLASS = {"_p__dwg_object_ACSH_REVOLVE_CLASS", "Dwg_Object_ACSH_REVOLVE_CLASS *|struct _dwg_object_ACSH_REVOLVE_CLASS *|_dwg_object_ACSH_REVOLVE_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_SPHERE_CLASS = {"_p__dwg_object_ACSH_SPHERE_CLASS", "Dwg_Object_ACSH_SPHERE_CLASS *|struct _dwg_object_ACSH_SPHERE_CLASS *|_dwg_object_ACSH_SPHERE_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_SWEEP_CLASS = {"_p__dwg_object_ACSH_SWEEP_CLASS", "Dwg_Object_ACSH_SWEEP_CLASS *|struct _dwg_object_ACSH_SWEEP_CLASS *|_dwg_object_ACSH_SWEEP_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_TORUS_CLASS = {"_p__dwg_object_ACSH_TORUS_CLASS", "Dwg_Object_ACSH_TORUS_CLASS *|struct _dwg_object_ACSH_TORUS_CLASS *|_dwg_object_ACSH_TORUS_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ACSH_WEDGE_CLASS = {"_p__dwg_object_ACSH_WEDGE_CLASS", "Dwg_Object_ACSH_WEDGE_CLASS *|struct _dwg_object_ACSH_WEDGE_CLASS *|_dwg_object_ACSH_WEDGE_CLASS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ALDIMOBJECTCONTEXTDATA = {"_p__dwg_object_ALDIMOBJECTCONTEXTDATA", "Dwg_Object_ALDIMOBJECTCONTEXTDATA *|struct _dwg_object_ALDIMOBJECTCONTEXTDATA *|_dwg_object_ALDIMOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ANGDIMOBJECTCONTEXTDATA = {"_p__dwg_object_ANGDIMOBJECTCONTEXTDATA", "Dwg_Object_ANGDIMOBJECTCONTEXTDATA *|struct _dwg_object_ANGDIMOBJECTCONTEXTDATA *|_dwg_object_ANGDIMOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA = {"_p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA", "Dwg_Object_ANNOTSCALEOBJECTCONTEXTDATA *|struct _dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *|_dwg_object_ANNOTSCALEOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_APPID = {"_p__dwg_object_APPID", "Dwg_Object_APPID *|struct _dwg_object_APPID *|_dwg_object_APPID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_APPID_CONTROL = {"_p__dwg_object_APPID_CONTROL", "Dwg_Object_APPID_CONTROL *|struct _dwg_object_APPID_CONTROL *|_dwg_object_APPID_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOC2DCONSTRAINTGROUP = {"_p__dwg_object_ASSOC2DCONSTRAINTGROUP", "Dwg_Object_ASSOC2DCONSTRAINTGROUP *|struct _dwg_object_ASSOC2DCONSTRAINTGROUP *|_dwg_object_ASSOC2DCONSTRAINTGROUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY = {"_p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY", "Dwg_Object_ASSOC3POINTANGULARDIMACTIONBODY *|struct _dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *|_dwg_object_ASSOC3POINTANGULARDIMACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCACTION = {"_p__dwg_object_ASSOCACTION", "Dwg_Object_ASSOCACTION *|struct _dwg_object_ASSOCACTION *|_dwg_object_ASSOCACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCACTIONPARAM = {"_p__dwg_object_ASSOCACTIONPARAM", "Dwg_Object_ASSOCACTIONPARAM *|struct _dwg_object_ASSOCACTIONPARAM *|_dwg_object_ASSOCACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCALIGNEDDIMACTIONBODY = {"_p__dwg_object_ASSOCALIGNEDDIMACTIONBODY", "Dwg_Object_ASSOCALIGNEDDIMACTIONBODY *|struct _dwg_object_ASSOCALIGNEDDIMACTIONBODY *|_dwg_object_ASSOCALIGNEDDIMACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCARRAYACTIONBODY = {"_p__dwg_object_ASSOCARRAYACTIONBODY", "Dwg_Object_ASSOCARRAYACTIONBODY *|struct _dwg_object_ASSOCARRAYACTIONBODY *|_dwg_object_ASSOCARRAYACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCARRAYMODIFYACTIONBODY = {"_p__dwg_object_ASSOCARRAYMODIFYACTIONBODY", "Dwg_Object_ASSOCARRAYMODIFYACTIONBODY *|struct _dwg_object_ASSOCARRAYMODIFYACTIONBODY *|_dwg_object_ASSOCARRAYMODIFYACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCASMBODYACTIONPARAM = {"_p__dwg_object_ASSOCASMBODYACTIONPARAM", "Dwg_Object_ASSOCASMBODYACTIONPARAM *|struct _dwg_object_ASSOCASMBODYACTIONPARAM *|_dwg_object_ASSOCASMBODYACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCBLENDSURFACEACTIONBODY = {"_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY", "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY *|struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY *|_dwg_object_ASSOCBLENDSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCCOMPOUNDACTIONPARAM = {"_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM", "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM *|struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM *|_dwg_object_ASSOCCOMPOUNDACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCDEPENDENCY = {"_p__dwg_object_ASSOCDEPENDENCY", "Dwg_Object_ASSOCDEPENDENCY *|struct _dwg_object_ASSOCDEPENDENCY *|_dwg_object_ASSOCDEPENDENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCDIMDEPENDENCYBODY = {"_p__dwg_object_ASSOCDIMDEPENDENCYBODY", "Dwg_Object_ASSOCDIMDEPENDENCYBODY *|struct _dwg_object_ASSOCDIMDEPENDENCYBODY *|_dwg_object_ASSOCDIMDEPENDENCYBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCEDGEACTIONPARAM = {"_p__dwg_object_ASSOCEDGEACTIONPARAM", "Dwg_Object_ASSOCEDGEACTIONPARAM *|struct _dwg_object_ASSOCEDGEACTIONPARAM *|_dwg_object_ASSOCEDGEACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCEDGECHAMFERACTIONBODY = {"_p__dwg_object_ASSOCEDGECHAMFERACTIONBODY", "Dwg_Object_ASSOCEDGECHAMFERACTIONBODY *|struct _dwg_object_ASSOCEDGECHAMFERACTIONBODY *|_dwg_object_ASSOCEDGECHAMFERACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCEDGEFILLETACTIONBODY = {"_p__dwg_object_ASSOCEDGEFILLETACTIONBODY", "Dwg_Object_ASSOCEDGEFILLETACTIONBODY *|struct _dwg_object_ASSOCEDGEFILLETACTIONBODY *|_dwg_object_ASSOCEDGEFILLETACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY = {"_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY", "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY *|struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY *|_dwg_object_ASSOCEXTENDSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY = {"_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY", "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY *|struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *|_dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCFACEACTIONPARAM = {"_p__dwg_object_ASSOCFACEACTIONPARAM", "Dwg_Object_ASSOCFACEACTIONPARAM *|struct _dwg_object_ASSOCFACEACTIONPARAM *|_dwg_object_ASSOCFACEACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCFILLETSURFACEACTIONBODY = {"_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY", "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY *|struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY *|_dwg_object_ASSOCFILLETSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCGEOMDEPENDENCY = {"_p__dwg_object_ASSOCGEOMDEPENDENCY", "Dwg_Object_ASSOCGEOMDEPENDENCY *|struct _dwg_object_ASSOCGEOMDEPENDENCY *|_dwg_object_ASSOCGEOMDEPENDENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY = {"_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY", "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY *|struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *|_dwg_object_ASSOCLOFTEDSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCMLEADERACTIONBODY = {"_p__dwg_object_ASSOCMLEADERACTIONBODY", "Dwg_Object_ASSOCMLEADERACTIONBODY *|struct _dwg_object_ASSOCMLEADERACTIONBODY *|_dwg_object_ASSOCMLEADERACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCNETWORK = {"_p__dwg_object_ASSOCNETWORK", "Dwg_Object_ASSOCNETWORK *|struct _dwg_object_ASSOCNETWORK *|_dwg_object_ASSOCNETWORK *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY = {"_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY", "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY *|struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY *|_dwg_object_ASSOCNETWORKSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCOBJECTACTIONPARAM = {"_p__dwg_object_ASSOCOBJECTACTIONPARAM", "Dwg_Object_ASSOCOBJECTACTIONPARAM *|struct _dwg_object_ASSOCOBJECTACTIONPARAM *|_dwg_object_ASSOCOBJECTACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY = {"_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY", "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY *|struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY *|_dwg_object_ASSOCOFFSETSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCORDINATEDIMACTIONBODY = {"_p__dwg_object_ASSOCORDINATEDIMACTIONBODY", "Dwg_Object_ASSOCORDINATEDIMACTIONBODY *|struct _dwg_object_ASSOCORDINATEDIMACTIONBODY *|_dwg_object_ASSOCORDINATEDIMACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM = {"_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM", "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM *|struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *|_dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCPATCHSURFACEACTIONBODY = {"_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY", "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY *|struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY *|_dwg_object_ASSOCPATCHSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCPATHACTIONPARAM = {"_p__dwg_object_ASSOCPATHACTIONPARAM", "Dwg_Object_ASSOCPATHACTIONPARAM *|struct _dwg_object_ASSOCPATHACTIONPARAM *|_dwg_object_ASSOCPATHACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCPERSSUBENTMANAGER = {"_p__dwg_object_ASSOCPERSSUBENTMANAGER", "Dwg_Object_ASSOCPERSSUBENTMANAGER *|struct _dwg_object_ASSOCPERSSUBENTMANAGER *|_dwg_object_ASSOCPERSSUBENTMANAGER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCPLANESURFACEACTIONBODY = {"_p__dwg_object_ASSOCPLANESURFACEACTIONBODY", "Dwg_Object_ASSOCPLANESURFACEACTIONBODY *|struct _dwg_object_ASSOCPLANESURFACEACTIONBODY *|_dwg_object_ASSOCPLANESURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCPOINTREFACTIONPARAM = {"_p__dwg_object_ASSOCPOINTREFACTIONPARAM", "Dwg_Object_ASSOCPOINTREFACTIONPARAM *|struct _dwg_object_ASSOCPOINTREFACTIONPARAM *|_dwg_object_ASSOCPOINTREFACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY = {"_p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY", "Dwg_Object_ASSOCRESTOREENTITYSTATEACTIONBODY *|struct _dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *|_dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY = {"_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY", "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY *|struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *|_dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCROTATEDDIMACTIONBODY = {"_p__dwg_object_ASSOCROTATEDDIMACTIONBODY", "Dwg_Object_ASSOCROTATEDDIMACTIONBODY *|struct _dwg_object_ASSOCROTATEDDIMACTIONBODY *|_dwg_object_ASSOCROTATEDDIMACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY = {"_p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY", "Dwg_Object_ASSOCSWEPTSURFACEACTIONBODY *|struct _dwg_object_ASSOCSWEPTSURFACEACTIONBODY *|_dwg_object_ASSOCSWEPTSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCTRIMSURFACEACTIONBODY = {"_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY", "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY *|struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY *|_dwg_object_ASSOCTRIMSURFACEACTIONBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCVALUEDEPENDENCY = {"_p__dwg_object_ASSOCVALUEDEPENDENCY", "Dwg_Object_ASSOCVALUEDEPENDENCY *|struct _dwg_object_ASSOCVALUEDEPENDENCY *|_dwg_object_ASSOCVALUEDEPENDENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCVARIABLE = {"_p__dwg_object_ASSOCVARIABLE", "Dwg_Object_ASSOCVARIABLE *|struct _dwg_object_ASSOCVARIABLE *|_dwg_object_ASSOCVARIABLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ASSOCVERTEXACTIONPARAM = {"_p__dwg_object_ASSOCVERTEXACTIONPARAM", "Dwg_Object_ASSOCVERTEXACTIONPARAM *|struct _dwg_object_ASSOCVERTEXACTIONPARAM *|_dwg_object_ASSOCVERTEXACTIONPARAM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLKREFOBJECTCONTEXTDATA = {"_p__dwg_object_BLKREFOBJECTCONTEXTDATA", "Dwg_Object_BLKREFOBJECTCONTEXTDATA *|struct _dwg_object_BLKREFOBJECTCONTEXTDATA *|_dwg_object_BLKREFOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER", "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *|_dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKALIGNMENTGRIP = {"_p__dwg_object_BLOCKALIGNMENTGRIP", "Dwg_Object_BLOCKALIGNMENTGRIP *|struct _dwg_object_BLOCKALIGNMENTGRIP *|_dwg_object_BLOCKALIGNMENTGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKALIGNMENTPARAMETER = {"_p__dwg_object_BLOCKALIGNMENTPARAMETER", "Dwg_Object_BLOCKALIGNMENTPARAMETER *|struct _dwg_object_BLOCKALIGNMENTPARAMETER *|_dwg_object_BLOCKALIGNMENTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER", "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *|_dwg_object_BLOCKANGULARCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKARRAYACTION = {"_p__dwg_object_BLOCKARRAYACTION", "Dwg_Object_BLOCKARRAYACTION *|struct _dwg_object_BLOCKARRAYACTION *|_dwg_object_BLOCKARRAYACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKBASEPOINTPARAMETER = {"_p__dwg_object_BLOCKBASEPOINTPARAMETER", "Dwg_Object_BLOCKBASEPOINTPARAMETER *|struct _dwg_object_BLOCKBASEPOINTPARAMETER *|_dwg_object_BLOCKBASEPOINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER", "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *|_dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKFLIPACTION = {"_p__dwg_object_BLOCKFLIPACTION", "Dwg_Object_BLOCKFLIPACTION *|struct _dwg_object_BLOCKFLIPACTION *|_dwg_object_BLOCKFLIPACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKFLIPGRIP = {"_p__dwg_object_BLOCKFLIPGRIP", "Dwg_Object_BLOCKFLIPGRIP *|struct _dwg_object_BLOCKFLIPGRIP *|_dwg_object_BLOCKFLIPGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKFLIPPARAMETER = {"_p__dwg_object_BLOCKFLIPPARAMETER", "Dwg_Object_BLOCKFLIPPARAMETER *|struct _dwg_object_BLOCKFLIPPARAMETER *|_dwg_object_BLOCKFLIPPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT = {"_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT", "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT *|struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT *|_dwg_object_BLOCKGRIPLOCATIONCOMPONENT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *|_dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER", "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *|_dwg_object_BLOCKLINEARCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLINEARGRIP = {"_p__dwg_object_BLOCKLINEARGRIP", "Dwg_Object_BLOCKLINEARGRIP *|struct _dwg_object_BLOCKLINEARGRIP *|_dwg_object_BLOCKLINEARGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLINEARPARAMETER = {"_p__dwg_object_BLOCKLINEARPARAMETER", "Dwg_Object_BLOCKLINEARPARAMETER *|struct _dwg_object_BLOCKLINEARPARAMETER *|_dwg_object_BLOCKLINEARPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLOOKUPACTION = {"_p__dwg_object_BLOCKLOOKUPACTION", "Dwg_Object_BLOCKLOOKUPACTION *|struct _dwg_object_BLOCKLOOKUPACTION *|_dwg_object_BLOCKLOOKUPACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLOOKUPGRIP = {"_p__dwg_object_BLOCKLOOKUPGRIP", "Dwg_Object_BLOCKLOOKUPGRIP *|struct _dwg_object_BLOCKLOOKUPGRIP *|_dwg_object_BLOCKLOOKUPGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKLOOKUPPARAMETER = {"_p__dwg_object_BLOCKLOOKUPPARAMETER", "Dwg_Object_BLOCKLOOKUPPARAMETER *|struct _dwg_object_BLOCKLOOKUPPARAMETER *|_dwg_object_BLOCKLOOKUPPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKMOVEACTION = {"_p__dwg_object_BLOCKMOVEACTION", "Dwg_Object_BLOCKMOVEACTION *|struct _dwg_object_BLOCKMOVEACTION *|_dwg_object_BLOCKMOVEACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPARAMDEPENDENCYBODY = {"_p__dwg_object_BLOCKPARAMDEPENDENCYBODY", "Dwg_Object_BLOCKPARAMDEPENDENCYBODY *|struct _dwg_object_BLOCKPARAMDEPENDENCYBODY *|_dwg_object_BLOCKPARAMDEPENDENCYBODY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPOINTPARAMETER = {"_p__dwg_object_BLOCKPOINTPARAMETER", "Dwg_Object_BLOCKPOINTPARAMETER *|struct _dwg_object_BLOCKPOINTPARAMETER *|_dwg_object_BLOCKPOINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPOLARGRIP = {"_p__dwg_object_BLOCKPOLARGRIP", "Dwg_Object_BLOCKPOLARGRIP *|struct _dwg_object_BLOCKPOLARGRIP *|_dwg_object_BLOCKPOLARGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPOLARPARAMETER = {"_p__dwg_object_BLOCKPOLARPARAMETER", "Dwg_Object_BLOCKPOLARPARAMETER *|struct _dwg_object_BLOCKPOLARPARAMETER *|_dwg_object_BLOCKPOLARPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPOLARSTRETCHACTION = {"_p__dwg_object_BLOCKPOLARSTRETCHACTION", "Dwg_Object_BLOCKPOLARSTRETCHACTION *|struct _dwg_object_BLOCKPOLARSTRETCHACTION *|_dwg_object_BLOCKPOLARSTRETCHACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPROPERTIESTABLE = {"_p__dwg_object_BLOCKPROPERTIESTABLE", "Dwg_Object_BLOCKPROPERTIESTABLE *|struct _dwg_object_BLOCKPROPERTIESTABLE *|_dwg_object_BLOCKPROPERTIESTABLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKPROPERTIESTABLEGRIP = {"_p__dwg_object_BLOCKPROPERTIESTABLEGRIP", "Dwg_Object_BLOCKPROPERTIESTABLEGRIP *|struct _dwg_object_BLOCKPROPERTIESTABLEGRIP *|_dwg_object_BLOCKPROPERTIESTABLEGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *|_dwg_object_BLOCKRADIALCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKREPRESENTATION = {"_p__dwg_object_BLOCKREPRESENTATION", "Dwg_Object_BLOCKREPRESENTATION *|struct _dwg_object_BLOCKREPRESENTATION *|_dwg_object_BLOCKREPRESENTATION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKROTATEACTION = {"_p__dwg_object_BLOCKROTATEACTION", "Dwg_Object_BLOCKROTATEACTION *|struct _dwg_object_BLOCKROTATEACTION *|_dwg_object_BLOCKROTATEACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKROTATIONGRIP = {"_p__dwg_object_BLOCKROTATIONGRIP", "Dwg_Object_BLOCKROTATIONGRIP *|struct _dwg_object_BLOCKROTATIONGRIP *|_dwg_object_BLOCKROTATIONGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKROTATIONPARAMETER = {"_p__dwg_object_BLOCKROTATIONPARAMETER", "Dwg_Object_BLOCKROTATIONPARAMETER *|struct _dwg_object_BLOCKROTATIONPARAMETER *|_dwg_object_BLOCKROTATIONPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKSCALEACTION = {"_p__dwg_object_BLOCKSCALEACTION", "Dwg_Object_BLOCKSCALEACTION *|struct _dwg_object_BLOCKSCALEACTION *|_dwg_object_BLOCKSCALEACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKSTRETCHACTION = {"_p__dwg_object_BLOCKSTRETCHACTION", "Dwg_Object_BLOCKSTRETCHACTION *|struct _dwg_object_BLOCKSTRETCHACTION *|_dwg_object_BLOCKSTRETCHACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKUSERPARAMETER = {"_p__dwg_object_BLOCKUSERPARAMETER", "Dwg_Object_BLOCKUSERPARAMETER *|struct _dwg_object_BLOCKUSERPARAMETER *|_dwg_object_BLOCKUSERPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER = {"_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER *|struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *|_dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKVISIBILITYGRIP = {"_p__dwg_object_BLOCKVISIBILITYGRIP", "Dwg_Object_BLOCKVISIBILITYGRIP *|struct _dwg_object_BLOCKVISIBILITYGRIP *|_dwg_object_BLOCKVISIBILITYGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKVISIBILITYPARAMETER = {"_p__dwg_object_BLOCKVISIBILITYPARAMETER", "Dwg_Object_BLOCKVISIBILITYPARAMETER *|struct _dwg_object_BLOCKVISIBILITYPARAMETER *|_dwg_object_BLOCKVISIBILITYPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKXYGRIP = {"_p__dwg_object_BLOCKXYGRIP", "Dwg_Object_BLOCKXYGRIP *|struct _dwg_object_BLOCKXYGRIP *|_dwg_object_BLOCKXYGRIP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCKXYPARAMETER = {"_p__dwg_object_BLOCKXYPARAMETER", "Dwg_Object_BLOCKXYPARAMETER *|struct _dwg_object_BLOCKXYPARAMETER *|_dwg_object_BLOCKXYPARAMETER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCK_CONTROL = {"_p__dwg_object_BLOCK_CONTROL", "Dwg_Object_BLOCK_CONTROL *|struct _dwg_object_BLOCK_CONTROL *|_dwg_object_BLOCK_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BLOCK_HEADER = {"_p__dwg_object_BLOCK_HEADER", "Dwg_Object_BLOCK_HEADER *|struct _dwg_object_BLOCK_HEADER *|_dwg_object_BLOCK_HEADER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BREAKDATA = {"_p__dwg_object_BREAKDATA", "Dwg_Object_BREAKDATA *|struct _dwg_object_BREAKDATA *|_dwg_object_BREAKDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_BREAKPOINTREF = {"_p__dwg_object_BREAKPOINTREF", "Dwg_Object_BREAKPOINTREF *|struct _dwg_object_BREAKPOINTREF *|_dwg_object_BREAKPOINTREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_CELLSTYLEMAP = {"_p__dwg_object_CELLSTYLEMAP", "Dwg_Object_CELLSTYLEMAP *|struct _dwg_object_CELLSTYLEMAP *|_dwg_object_CELLSTYLEMAP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_CONTEXTDATAMANAGER = {"_p__dwg_object_CONTEXTDATAMANAGER", "Dwg_Object_CONTEXTDATAMANAGER *|struct _dwg_object_CONTEXTDATAMANAGER *|_dwg_object_CONTEXTDATAMANAGER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_CSACDOCUMENTOPTIONS = {"_p__dwg_object_CSACDOCUMENTOPTIONS", "Dwg_Object_CSACDOCUMENTOPTIONS *|struct _dwg_object_CSACDOCUMENTOPTIONS *|_dwg_object_CSACDOCUMENTOPTIONS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_CURVEPATH = {"_p__dwg_object_CURVEPATH", "Dwg_Object_CURVEPATH *|struct _dwg_object_CURVEPATH *|_dwg_object_CURVEPATH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DATALINK = {"_p__dwg_object_DATALINK", "Dwg_Object_DATALINK *|struct _dwg_object_DATALINK *|_dwg_object_DATALINK *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DATATABLE = {"_p__dwg_object_DATATABLE", "Dwg_Object_DATATABLE *|struct _dwg_object_DATATABLE *|_dwg_object_DATATABLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DBCOLOR = {"_p__dwg_object_DBCOLOR", "Dwg_Object_DBCOLOR *|struct _dwg_object_DBCOLOR *|_dwg_object_DBCOLOR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DETAILVIEWSTYLE = {"_p__dwg_object_DETAILVIEWSTYLE", "Dwg_Object_DETAILVIEWSTYLE *|struct _dwg_object_DETAILVIEWSTYLE *|_dwg_object_DETAILVIEWSTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DICTIONARY = {"_p__dwg_object_DICTIONARY", "Dwg_Object_DICTIONARY *|struct _dwg_object_DICTIONARY *|_dwg_object_DICTIONARY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DICTIONARYVAR = {"_p__dwg_object_DICTIONARYVAR", "Dwg_Object_DICTIONARYVAR *|struct _dwg_object_DICTIONARYVAR *|_dwg_object_DICTIONARYVAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DICTIONARYWDFLT = {"_p__dwg_object_DICTIONARYWDFLT", "Dwg_Object_DICTIONARYWDFLT *|struct _dwg_object_DICTIONARYWDFLT *|_dwg_object_DICTIONARYWDFLT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DIMASSOC = {"_p__dwg_object_DIMASSOC", "Dwg_Object_DIMASSOC *|struct _dwg_object_DIMASSOC *|_dwg_object_DIMASSOC *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DIMSTYLE = {"_p__dwg_object_DIMSTYLE", "Dwg_Object_DIMSTYLE *|struct _dwg_object_DIMSTYLE *|_dwg_object_DIMSTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DIMSTYLE_CONTROL = {"_p__dwg_object_DIMSTYLE_CONTROL", "Dwg_Object_DIMSTYLE_CONTROL *|struct _dwg_object_DIMSTYLE_CONTROL *|_dwg_object_DIMSTYLE_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DMDIMOBJECTCONTEXTDATA = {"_p__dwg_object_DMDIMOBJECTCONTEXTDATA", "Dwg_Object_DMDIMOBJECTCONTEXTDATA *|struct _dwg_object_DMDIMOBJECTCONTEXTDATA *|_dwg_object_DMDIMOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DUMMY = {"_p__dwg_object_DUMMY", "Dwg_Object_DUMMY *|struct _dwg_object_DUMMY *|_dwg_object_DUMMY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DYNAMICBLOCKPROXYNODE = {"_p__dwg_object_DYNAMICBLOCKPROXYNODE", "Dwg_Object_DYNAMICBLOCKPROXYNODE *|struct _dwg_object_DYNAMICBLOCKPROXYNODE *|_dwg_object_DYNAMICBLOCKPROXYNODE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_DYNAMICBLOCKPURGEPREVENTER = {"_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER", "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER *|struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER *|_dwg_object_DYNAMICBLOCKPURGEPREVENTER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_EVALUATION_GRAPH = {"_p__dwg_object_EVALUATION_GRAPH", "Dwg_Object_EVALUATION_GRAPH *|struct _dwg_object_EVALUATION_GRAPH *|_dwg_object_EVALUATION_GRAPH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_FCFOBJECTCONTEXTDATA = {"_p__dwg_object_FCFOBJECTCONTEXTDATA", "Dwg_Object_FCFOBJECTCONTEXTDATA *|struct _dwg_object_FCFOBJECTCONTEXTDATA *|_dwg_object_FCFOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_FIELD = {"_p__dwg_object_FIELD", "Dwg_Object_FIELD *|struct _dwg_object_FIELD *|_dwg_object_FIELD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_FIELDLIST = {"_p__dwg_object_FIELDLIST", "Dwg_Object_FIELDLIST *|struct _dwg_object_FIELDLIST *|_dwg_object_FIELDLIST *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_GEODATA = {"_p__dwg_object_GEODATA", "Dwg_Object_GEODATA *|struct _dwg_object_GEODATA *|_dwg_object_GEODATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_GEOMAPIMAGE = {"_p__dwg_object_GEOMAPIMAGE", "Dwg_Object_GEOMAPIMAGE *|struct _dwg_object_GEOMAPIMAGE *|_dwg_object_GEOMAPIMAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_GRADIENT_BACKGROUND = {"_p__dwg_object_GRADIENT_BACKGROUND", "Dwg_Object_GRADIENT_BACKGROUND *|struct _dwg_object_GRADIENT_BACKGROUND *|_dwg_object_GRADIENT_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_GROUND_PLANE_BACKGROUND = {"_p__dwg_object_GROUND_PLANE_BACKGROUND", "Dwg_Object_GROUND_PLANE_BACKGROUND *|struct _dwg_object_GROUND_PLANE_BACKGROUND *|_dwg_object_GROUND_PLANE_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_GROUP = {"_p__dwg_object_GROUP", "Dwg_Object_GROUP *|struct _dwg_object_GROUP *|_dwg_object_GROUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_IBL_BACKGROUND = {"_p__dwg_object_IBL_BACKGROUND", "Dwg_Object_IBL_BACKGROUND *|struct _dwg_object_IBL_BACKGROUND *|_dwg_object_IBL_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_IDBUFFER = {"_p__dwg_object_IDBUFFER", "Dwg_Object_IDBUFFER *|struct _dwg_object_IDBUFFER *|_dwg_object_IDBUFFER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_IMAGEDEF = {"_p__dwg_object_IMAGEDEF", "Dwg_Object_IMAGEDEF *|struct _dwg_object_IMAGEDEF *|_dwg_object_IMAGEDEF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_IMAGEDEF_REACTOR = {"_p__dwg_object_IMAGEDEF_REACTOR", "Dwg_Object_IMAGEDEF_REACTOR *|struct _dwg_object_IMAGEDEF_REACTOR *|_dwg_object_IMAGEDEF_REACTOR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_IMAGE_BACKGROUND = {"_p__dwg_object_IMAGE_BACKGROUND", "Dwg_Object_IMAGE_BACKGROUND *|struct _dwg_object_IMAGE_BACKGROUND *|_dwg_object_IMAGE_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_INDEX = {"_p__dwg_object_INDEX", "Dwg_Object_INDEX *|struct _dwg_object_INDEX *|_dwg_object_INDEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LAYER = {"_p__dwg_object_LAYER", "Dwg_Object_LAYER *|struct _dwg_object_LAYER *|_dwg_object_LAYER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LAYERFILTER = {"_p__dwg_object_LAYERFILTER", "Dwg_Object_LAYERFILTER *|struct _dwg_object_LAYERFILTER *|_dwg_object_LAYERFILTER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LAYER_CONTROL = {"_p__dwg_object_LAYER_CONTROL", "Dwg_Object_LAYER_CONTROL *|struct _dwg_object_LAYER_CONTROL *|_dwg_object_LAYER_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LAYER_INDEX = {"_p__dwg_object_LAYER_INDEX", "Dwg_Object_LAYER_INDEX *|struct _dwg_object_LAYER_INDEX *|_dwg_object_LAYER_INDEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LAYOUT = {"_p__dwg_object_LAYOUT", "Dwg_Object_LAYOUT *|struct _dwg_object_LAYOUT *|_dwg_object_LAYOUT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LEADEROBJECTCONTEXTDATA = {"_p__dwg_object_LEADEROBJECTCONTEXTDATA", "Dwg_Object_LEADEROBJECTCONTEXTDATA *|struct _dwg_object_LEADEROBJECTCONTEXTDATA *|_dwg_object_LEADEROBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LIGHTLIST = {"_p__dwg_object_LIGHTLIST", "Dwg_Object_LIGHTLIST *|struct _dwg_object_LIGHTLIST *|_dwg_object_LIGHTLIST *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LONG_TRANSACTION = {"_p__dwg_object_LONG_TRANSACTION", "Dwg_Object_LONG_TRANSACTION *|struct _dwg_object_LONG_TRANSACTION *|_dwg_object_LONG_TRANSACTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LTYPE = {"_p__dwg_object_LTYPE", "Dwg_Object_LTYPE *|struct _dwg_object_LTYPE *|_dwg_object_LTYPE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_LTYPE_CONTROL = {"_p__dwg_object_LTYPE_CONTROL", "Dwg_Object_LTYPE_CONTROL *|struct _dwg_object_LTYPE_CONTROL *|_dwg_object_LTYPE_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MATERIAL = {"_p__dwg_object_MATERIAL", "Dwg_Object_MATERIAL *|struct _dwg_object_MATERIAL *|_dwg_object_MATERIAL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MENTALRAYRENDERSETTINGS = {"_p__dwg_object_MENTALRAYRENDERSETTINGS", "Dwg_Object_MENTALRAYRENDERSETTINGS *|struct _dwg_object_MENTALRAYRENDERSETTINGS *|_dwg_object_MENTALRAYRENDERSETTINGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MLEADEROBJECTCONTEXTDATA = {"_p__dwg_object_MLEADEROBJECTCONTEXTDATA", "Dwg_Object_MLEADEROBJECTCONTEXTDATA *|struct _dwg_object_MLEADEROBJECTCONTEXTDATA *|_dwg_object_MLEADEROBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MLEADERSTYLE = {"_p__dwg_object_MLEADERSTYLE", "Dwg_Object_MLEADERSTYLE *|struct _dwg_object_MLEADERSTYLE *|_dwg_object_MLEADERSTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MLINESTYLE = {"_p__dwg_object_MLINESTYLE", "Dwg_Object_MLINESTYLE *|struct _dwg_object_MLINESTYLE *|_dwg_object_MLINESTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MOTIONPATH = {"_p__dwg_object_MOTIONPATH", "Dwg_Object_MOTIONPATH *|struct _dwg_object_MOTIONPATH *|_dwg_object_MOTIONPATH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA = {"_p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA", "Dwg_Object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *|struct _dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *|_dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_MTEXTOBJECTCONTEXTDATA = {"_p__dwg_object_MTEXTOBJECTCONTEXTDATA", "Dwg_Object_MTEXTOBJECTCONTEXTDATA *|struct _dwg_object_MTEXTOBJECTCONTEXTDATA *|_dwg_object_MTEXTOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_NAVISWORKSMODELDEF = {"_p__dwg_object_NAVISWORKSMODELDEF", "Dwg_Object_NAVISWORKSMODELDEF *|struct _dwg_object_NAVISWORKSMODELDEF *|_dwg_object_NAVISWORKSMODELDEF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_OBJECT_PTR = {"_p__dwg_object_OBJECT_PTR", "Dwg_Object_OBJECT_PTR *|struct _dwg_object_OBJECT_PTR *|_dwg_object_OBJECT_PTR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ORDDIMOBJECTCONTEXTDATA = {"_p__dwg_object_ORDDIMOBJECTCONTEXTDATA", "Dwg_Object_ORDDIMOBJECTCONTEXTDATA *|struct _dwg_object_ORDDIMOBJECTCONTEXTDATA *|_dwg_object_ORDDIMOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_PARTIAL_VIEWING_INDEX = {"_p__dwg_object_PARTIAL_VIEWING_INDEX", "Dwg_Object_PARTIAL_VIEWING_INDEX *|struct _dwg_object_PARTIAL_VIEWING_INDEX *|_dwg_object_PARTIAL_VIEWING_INDEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_PERSUBENTMGR = {"_p__dwg_object_PERSUBENTMGR", "Dwg_Object_PERSUBENTMGR *|struct _dwg_object_PERSUBENTMGR *|_dwg_object_PERSUBENTMGR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_PLACEHOLDER = {"_p__dwg_object_PLACEHOLDER", "Dwg_Object_PLACEHOLDER *|struct _dwg_object_PLACEHOLDER *|_dwg_object_PLACEHOLDER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_PLOTSETTINGS = {"_p__dwg_object_PLOTSETTINGS", "Dwg_Object_PLOTSETTINGS *|struct _dwg_object_PLOTSETTINGS *|_dwg_object_PLOTSETTINGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTCLOUDCOLORMAP = {"_p__dwg_object_POINTCLOUDCOLORMAP", "Dwg_Object_POINTCLOUDCOLORMAP *|struct _dwg_object_POINTCLOUDCOLORMAP *|_dwg_object_POINTCLOUDCOLORMAP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTCLOUDDEF = {"_p__dwg_object_POINTCLOUDDEF", "Dwg_Object_POINTCLOUDDEF *|struct _dwg_object_POINTCLOUDDEF *|_dwg_object_POINTCLOUDDEF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTCLOUDDEFEX = {"_p__dwg_object_POINTCLOUDDEFEX", "Dwg_Object_POINTCLOUDDEFEX *|struct _dwg_object_POINTCLOUDDEFEX *|_dwg_object_POINTCLOUDDEFEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTCLOUDDEF_REACTOR = {"_p__dwg_object_POINTCLOUDDEF_REACTOR", "Dwg_Object_POINTCLOUDDEF_REACTOR *|struct _dwg_object_POINTCLOUDDEF_REACTOR *|_dwg_object_POINTCLOUDDEF_REACTOR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTCLOUDDEF_REACTOR_EX = {"_p__dwg_object_POINTCLOUDDEF_REACTOR_EX", "Dwg_Object_POINTCLOUDDEF_REACTOR_EX *|struct _dwg_object_POINTCLOUDDEF_REACTOR_EX *|_dwg_object_POINTCLOUDDEF_REACTOR_EX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_POINTPATH = {"_p__dwg_object_POINTPATH", "Dwg_Object_POINTPATH *|struct _dwg_object_POINTPATH *|_dwg_object_POINTPATH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_PROXY_OBJECT = {"_p__dwg_object_PROXY_OBJECT", "Dwg_Object_PROXY_OBJECT *|struct _dwg_object_PROXY_OBJECT *|_dwg_object_PROXY_OBJECT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RADIMLGOBJECTCONTEXTDATA = {"_p__dwg_object_RADIMLGOBJECTCONTEXTDATA", "Dwg_Object_RADIMLGOBJECTCONTEXTDATA *|struct _dwg_object_RADIMLGOBJECTCONTEXTDATA *|_dwg_object_RADIMLGOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RADIMOBJECTCONTEXTDATA = {"_p__dwg_object_RADIMOBJECTCONTEXTDATA", "Dwg_Object_RADIMOBJECTCONTEXTDATA *|struct _dwg_object_RADIMOBJECTCONTEXTDATA *|_dwg_object_RADIMOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RAPIDRTRENDERSETTINGS = {"_p__dwg_object_RAPIDRTRENDERSETTINGS", "Dwg_Object_RAPIDRTRENDERSETTINGS *|struct _dwg_object_RAPIDRTRENDERSETTINGS *|_dwg_object_RAPIDRTRENDERSETTINGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RASTERVARIABLES = {"_p__dwg_object_RASTERVARIABLES", "Dwg_Object_RASTERVARIABLES *|struct _dwg_object_RASTERVARIABLES *|_dwg_object_RASTERVARIABLES *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RENDERENTRY = {"_p__dwg_object_RENDERENTRY", "Dwg_Object_RENDERENTRY *|struct _dwg_object_RENDERENTRY *|_dwg_object_RENDERENTRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RENDERENVIRONMENT = {"_p__dwg_object_RENDERENVIRONMENT", "Dwg_Object_RENDERENVIRONMENT *|struct _dwg_object_RENDERENVIRONMENT *|_dwg_object_RENDERENVIRONMENT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RENDERGLOBAL = {"_p__dwg_object_RENDERGLOBAL", "Dwg_Object_RENDERGLOBAL *|struct _dwg_object_RENDERGLOBAL *|_dwg_object_RENDERGLOBAL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_RENDERSETTINGS = {"_p__dwg_object_RENDERSETTINGS", "Dwg_Object_RENDERSETTINGS *|struct _dwg_object_RENDERSETTINGS *|_dwg_object_RENDERSETTINGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SCALE = {"_p__dwg_object_SCALE", "Dwg_Object_SCALE *|struct _dwg_object_SCALE *|_dwg_object_SCALE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SECTIONVIEWSTYLE = {"_p__dwg_object_SECTIONVIEWSTYLE", "Dwg_Object_SECTIONVIEWSTYLE *|struct _dwg_object_SECTIONVIEWSTYLE *|_dwg_object_SECTIONVIEWSTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SECTION_MANAGER = {"_p__dwg_object_SECTION_MANAGER", "Dwg_Object_SECTION_MANAGER *|struct _dwg_object_SECTION_MANAGER *|_dwg_object_SECTION_MANAGER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SECTION_SETTINGS = {"_p__dwg_object_SECTION_SETTINGS", "Dwg_Object_SECTION_SETTINGS *|struct _dwg_object_SECTION_SETTINGS *|_dwg_object_SECTION_SETTINGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SKYLIGHT_BACKGROUND = {"_p__dwg_object_SKYLIGHT_BACKGROUND", "Dwg_Object_SKYLIGHT_BACKGROUND *|struct _dwg_object_SKYLIGHT_BACKGROUND *|_dwg_object_SKYLIGHT_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SOLID_BACKGROUND = {"_p__dwg_object_SOLID_BACKGROUND", "Dwg_Object_SOLID_BACKGROUND *|struct _dwg_object_SOLID_BACKGROUND *|_dwg_object_SOLID_BACKGROUND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SORTENTSTABLE = {"_p__dwg_object_SORTENTSTABLE", "Dwg_Object_SORTENTSTABLE *|struct _dwg_object_SORTENTSTABLE *|_dwg_object_SORTENTSTABLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SPATIAL_FILTER = {"_p__dwg_object_SPATIAL_FILTER", "Dwg_Object_SPATIAL_FILTER *|struct _dwg_object_SPATIAL_FILTER *|_dwg_object_SPATIAL_FILTER *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SPATIAL_INDEX = {"_p__dwg_object_SPATIAL_INDEX", "Dwg_Object_SPATIAL_INDEX *|struct _dwg_object_SPATIAL_INDEX *|_dwg_object_SPATIAL_INDEX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_STYLE = {"_p__dwg_object_STYLE", "Dwg_Object_STYLE *|struct _dwg_object_STYLE *|_dwg_object_STYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_STYLE_CONTROL = {"_p__dwg_object_STYLE_CONTROL", "Dwg_Object_STYLE_CONTROL *|struct _dwg_object_STYLE_CONTROL *|_dwg_object_STYLE_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SUN = {"_p__dwg_object_SUN", "Dwg_Object_SUN *|struct _dwg_object_SUN *|_dwg_object_SUN *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_SUNSTUDY = {"_p__dwg_object_SUNSTUDY", "Dwg_Object_SUNSTUDY *|struct _dwg_object_SUNSTUDY *|_dwg_object_SUNSTUDY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_TABLECONTENT = {"_p__dwg_object_TABLECONTENT", "Dwg_Object_TABLECONTENT *|struct _dwg_object_TABLECONTENT *|_dwg_object_TABLECONTENT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_TABLEGEOMETRY = {"_p__dwg_object_TABLEGEOMETRY", "Dwg_Object_TABLEGEOMETRY *|struct _dwg_object_TABLEGEOMETRY *|_dwg_object_TABLEGEOMETRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_TABLESTYLE = {"_p__dwg_object_TABLESTYLE", "Dwg_Object_TABLESTYLE *|struct _dwg_object_TABLESTYLE *|_dwg_object_TABLESTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_TEXTOBJECTCONTEXTDATA = {"_p__dwg_object_TEXTOBJECTCONTEXTDATA", "Dwg_Object_TEXTOBJECTCONTEXTDATA *|struct _dwg_object_TEXTOBJECTCONTEXTDATA *|_dwg_object_TEXTOBJECTCONTEXTDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_TVDEVICEPROPERTIES = {"_p__dwg_object_TVDEVICEPROPERTIES", "Dwg_Object_TVDEVICEPROPERTIES *|struct _dwg_object_TVDEVICEPROPERTIES *|_dwg_object_TVDEVICEPROPERTIES *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_UCS = {"_p__dwg_object_UCS", "Dwg_Object_UCS *|struct _dwg_object_UCS *|_dwg_object_UCS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_UCS_CONTROL = {"_p__dwg_object_UCS_CONTROL", "Dwg_Object_UCS_CONTROL *|struct _dwg_object_UCS_CONTROL *|_dwg_object_UCS_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_UNKNOWN_OBJ = {"_p__dwg_object_UNKNOWN_OBJ", "Dwg_Object_UNKNOWN_OBJ *|struct _dwg_object_UNKNOWN_OBJ *|_dwg_object_UNKNOWN_OBJ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VBA_PROJECT = {"_p__dwg_object_VBA_PROJECT", "Dwg_Object_VBA_PROJECT *|struct _dwg_object_VBA_PROJECT *|_dwg_object_VBA_PROJECT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VIEW = {"_p__dwg_object_VIEW", "Dwg_Object_VIEW *|struct _dwg_object_VIEW *|_dwg_object_VIEW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VIEW_CONTROL = {"_p__dwg_object_VIEW_CONTROL", "Dwg_Object_VIEW_CONTROL *|struct _dwg_object_VIEW_CONTROL *|_dwg_object_VIEW_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VISUALSTYLE = {"_p__dwg_object_VISUALSTYLE", "Dwg_Object_VISUALSTYLE *|struct _dwg_object_VISUALSTYLE *|_dwg_object_VISUALSTYLE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VPORT = {"_p__dwg_object_VPORT", "Dwg_Object_VPORT *|struct _dwg_object_VPORT *|_dwg_object_VPORT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VPORT_CONTROL = {"_p__dwg_object_VPORT_CONTROL", "Dwg_Object_VPORT_CONTROL *|struct _dwg_object_VPORT_CONTROL *|_dwg_object_VPORT_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VX_CONTROL = {"_p__dwg_object_VX_CONTROL", "Dwg_Object_VX_CONTROL *|struct _dwg_object_VX_CONTROL *|_dwg_object_VX_CONTROL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_VX_TABLE_RECORD = {"_p__dwg_object_VX_TABLE_RECORD", "Dwg_Object_VX_TABLE_RECORD *|struct _dwg_object_VX_TABLE_RECORD *|_dwg_object_VX_TABLE_RECORD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_WIPEOUTVARIABLES = {"_p__dwg_object_WIPEOUTVARIABLES", "Dwg_Object_WIPEOUTVARIABLES *|struct _dwg_object_WIPEOUTVARIABLES *|_dwg_object_WIPEOUTVARIABLES *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_XRECORD = {"_p__dwg_object_XRECORD", "Dwg_Object_XRECORD *|struct _dwg_object_XRECORD *|_dwg_object_XRECORD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_entity = {"_p__dwg_object_entity", "Dwg_Object_Entity *|struct _dwg_object_entity *|_dwg_object_entity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_entity_tio = {"_p__dwg_object_entity_tio", "_dwg_object_entity_tio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_object = {"_p__dwg_object_object", "Dwg_Object_Object *|struct _dwg_object_object *|_dwg_object_object *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_object_tio = {"_p__dwg_object_object_tio", "_dwg_object_object_tio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_ref = {"_p__dwg_object_ref", "BITCODE_H|Dwg_Object_Ref *|struct _dwg_object_ref *|_dwg_object_ref *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_object_tio = {"_p__dwg_object_tio", "_dwg_object_tio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_objfreespace = {"_p__dwg_objfreespace", "Dwg_ObjFreeSpace *|struct _dwg_objfreespace *|_dwg_objfreespace *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_resbuf = {"_p__dwg_resbuf", "Dwg_Resbuf *|struct _dwg_resbuf *|_dwg_resbuf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_resbuf_value = {"_p__dwg_resbuf_value", "_dwg_resbuf_value *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_revhistory = {"_p__dwg_revhistory", "Dwg_RevHistory *|struct _dwg_revhistory *|_dwg_revhistory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_secondheader = {"_p__dwg_secondheader", "Dwg_SecondHeader *|struct _dwg_secondheader *|_dwg_secondheader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_secondheader_handles = {"_p__dwg_secondheader_handles", "Dwg_SecondHeader_Handles *|struct _dwg_secondheader_handles *|_dwg_secondheader_handles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_secondheader_sections = {"_p__dwg_secondheader_sections", "Dwg_SecondHeader_Sections *|struct _dwg_secondheader_sections *|_dwg_secondheader_sections *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_section = {"_p__dwg_section", "Dwg_Section *|struct _dwg_section *|_dwg_section *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_security = {"_p__dwg_security", "Dwg_Security *|struct _dwg_security *|_dwg_security *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_struct = {"_p__dwg_struct", "Dwg_Data *|struct _dwg_struct *|_dwg_struct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_struct_fhdr = {"_p__dwg_struct_fhdr", "_dwg_struct_fhdr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_summaryinfo = {"_p__dwg_summaryinfo", "Dwg_SummaryInfo *|struct _dwg_summaryinfo *|_dwg_summaryinfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_template = {"_p__dwg_template", "Dwg_Template *|struct _dwg_template *|_dwg_template *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_time_bll = {"_p__dwg_time_bll", "BITCODE_TIMEBLL *|BITCODE_TIMERLL *|Dwg_Bitcode_TimeBLL *|struct _dwg_time_bll *|_dwg_time_bll *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__dwg_vbaproject = {"_p__dwg_vbaproject", "Dwg_VBAProject *|struct _dwg_vbaproject *|_dwg_vbaproject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__inthash = {"_p__inthash", "struct _inthash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "BITCODE_BD *|BITCODE_BT *|BITCODE_DD *|BITCODE_RD *|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_entity_DIMENSION_common = {"_p_dwg_entity_DIMENSION_common", "struct dwg_entity_DIMENSION_common *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_field_name_type_offset = {"_p_dwg_field_name_type_offset", "Dwg_DYNAPI_field *|struct dwg_field_name_type_offset *|dwg_field_name_type_offset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_obj_ent = {"_p_dwg_obj_ent", "dwg_obj_ent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_obj_generic = {"_p_dwg_obj_generic", "dwg_obj_generic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_obj_layer = {"_p_dwg_obj_layer", "dwg_obj_layer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_obj_obj = {"_p_dwg_obj_obj", "dwg_obj_obj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_object = {"_p_dwg_object", "dwg_object *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dwg_versions = {"_p_dwg_versions", "Dwg_Versions *|struct dwg_versions *|dwg_versions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t = {"_p_eed_data_t", "union eed_data_t *|eed_data_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_0 = {"_p_eed_data_t_eed_0", "eed_data_t_eed_0 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_0_r2007 = {"_p_eed_data_t_eed_0_r2007", "eed_data_t_eed_0_r2007 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_1 = {"_p_eed_data_t_eed_1", "eed_data_t_eed_1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_10 = {"_p_eed_data_t_eed_10", "eed_data_t_eed_10 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_2 = {"_p_eed_data_t_eed_2", "eed_data_t_eed_2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_3 = {"_p_eed_data_t_eed_3", "eed_data_t_eed_3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_4 = {"_p_eed_data_t_eed_4", "eed_data_t_eed_4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_40 = {"_p_eed_data_t_eed_40", "eed_data_t_eed_40 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_5 = {"_p_eed_data_t_eed_5", "eed_data_t_eed_5 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_70 = {"_p_eed_data_t_eed_70", "eed_data_t_eed_70 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_eed_data_t_eed_71 = {"_p_eed_data_t_eed_71", "eed_data_t_eed_71 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "BITCODE_BLd *|BITCODE_MC *|BITCODE_RLd *|Dwg_Entity_UNUSED *|int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "BITCODE_RLLd *|int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_abstractentity_UNDERLAY = {"_p_p__dwg_abstractentity_UNDERLAY", "Dwg_Entity_DGNUNDERLAY **|Dwg_Entity_DWFUNDERLAY **|Dwg_Entity_PDFUNDERLAY **|struct _dwg_abstractentity_UNDERLAY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS = {"_p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS", "Dwg_Object_ASSOCARRAYMODIFYPARAMETERS **|Dwg_Object_ASSOCARRAYPATHPARAMETERS **|Dwg_Object_ASSOCARRAYPOLARPARAMETERS **|Dwg_Object_ASSOCARRAYRECTANGULARPARAMETERS **|struct _dwg_abstractobject_ASSOCARRAYPARAMETERS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_abstractobject_UNDERLAYDEFINITION = {"_p_p__dwg_abstractobject_UNDERLAYDEFINITION", "Dwg_Object_DGNDEFINITION **|Dwg_Object_DWFDEFINITION **|Dwg_Object_PDFDEFINITION **|struct _dwg_abstractobject_UNDERLAYDEFINITION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_3DFACE = {"_p_p__dwg_entity_3DFACE", "Dwg_Entity__3DFACE **|struct _dwg_entity_3DFACE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_3DLINE = {"_p_p__dwg_entity_3DLINE", "Dwg_Entity__3DLINE **|struct _dwg_entity_3DLINE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_3DSOLID = {"_p_p__dwg_entity_3DSOLID", "Dwg_Entity_BODY **|Dwg_Entity_REGION **|Dwg_Entity__3DSOLID **|struct _dwg_entity_3DSOLID **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ARC = {"_p_p__dwg_entity_ARC", "Dwg_Entity_ARC **|struct _dwg_entity_ARC **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ARC_DIMENSION = {"_p_p__dwg_entity_ARC_DIMENSION", "Dwg_Entity_ARC_DIMENSION **|struct _dwg_entity_ARC_DIMENSION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ATTDEF = {"_p_p__dwg_entity_ATTDEF", "Dwg_Entity_ATTDEF **|struct _dwg_entity_ATTDEF **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ATTRIB = {"_p_p__dwg_entity_ATTRIB", "Dwg_Entity_ATTRIB **|struct _dwg_entity_ATTRIB **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_BLOCK = {"_p_p__dwg_entity_BLOCK", "Dwg_Entity_BLOCK **|struct _dwg_entity_BLOCK **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_CAMERA = {"_p_p__dwg_entity_CAMERA", "Dwg_Entity_CAMERA **|struct _dwg_entity_CAMERA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_CIRCLE = {"_p_p__dwg_entity_CIRCLE", "Dwg_Entity_CIRCLE **|struct _dwg_entity_CIRCLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_ALIGNED = {"_p_p__dwg_entity_DIMENSION_ALIGNED", "Dwg_Entity_DIMENSION_ALIGNED **|struct _dwg_entity_DIMENSION_ALIGNED **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_ANG2LN = {"_p_p__dwg_entity_DIMENSION_ANG2LN", "Dwg_Entity_DIMENSION_ANG2LN **|struct _dwg_entity_DIMENSION_ANG2LN **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_ANG3PT = {"_p_p__dwg_entity_DIMENSION_ANG3PT", "Dwg_Entity_DIMENSION_ANG3PT **|struct _dwg_entity_DIMENSION_ANG3PT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_DIAMETER = {"_p_p__dwg_entity_DIMENSION_DIAMETER", "Dwg_Entity_DIMENSION_DIAMETER **|struct _dwg_entity_DIMENSION_DIAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_LINEAR = {"_p_p__dwg_entity_DIMENSION_LINEAR", "Dwg_Entity_DIMENSION_LINEAR **|struct _dwg_entity_DIMENSION_LINEAR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_ORDINATE = {"_p_p__dwg_entity_DIMENSION_ORDINATE", "Dwg_Entity_DIMENSION_ORDINATE **|struct _dwg_entity_DIMENSION_ORDINATE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_DIMENSION_RADIUS = {"_p_p__dwg_entity_DIMENSION_RADIUS", "Dwg_Entity_DIMENSION_RADIUS **|struct _dwg_entity_DIMENSION_RADIUS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ELLIPSE = {"_p_p__dwg_entity_ELLIPSE", "Dwg_Entity_ELLIPSE **|struct _dwg_entity_ELLIPSE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ENDBLK = {"_p_p__dwg_entity_ENDBLK", "Dwg_Entity_ENDBLK **|struct _dwg_entity_ENDBLK **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_ENDREP = {"_p_p__dwg_entity_ENDREP", "Dwg_Entity_ENDREP **|struct _dwg_entity_ENDREP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_HATCH = {"_p_p__dwg_entity_HATCH", "Dwg_Entity_HATCH **|struct _dwg_entity_HATCH **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_HELIX = {"_p_p__dwg_entity_HELIX", "Dwg_Entity_HELIX **|struct _dwg_entity_HELIX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_IMAGE = {"_p_p__dwg_entity_IMAGE", "Dwg_Entity_IMAGE **|struct _dwg_entity_IMAGE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_INSERT = {"_p_p__dwg_entity_INSERT", "Dwg_Entity_INSERT **|struct _dwg_entity_INSERT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_JUMP = {"_p_p__dwg_entity_JUMP", "Dwg_Entity_JUMP **|struct _dwg_entity_JUMP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LARGE_RADIAL_DIMENSION = {"_p_p__dwg_entity_LARGE_RADIAL_DIMENSION", "Dwg_Entity_LARGE_RADIAL_DIMENSION **|struct _dwg_entity_LARGE_RADIAL_DIMENSION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LAYOUTPRINTCONFIG = {"_p_p__dwg_entity_LAYOUTPRINTCONFIG", "Dwg_Entity_LAYOUTPRINTCONFIG **|struct _dwg_entity_LAYOUTPRINTCONFIG **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LEADER = {"_p_p__dwg_entity_LEADER", "Dwg_Entity_LEADER **|struct _dwg_entity_LEADER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LIGHT = {"_p_p__dwg_entity_LIGHT", "Dwg_Entity_LIGHT **|struct _dwg_entity_LIGHT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LINE = {"_p_p__dwg_entity_LINE", "Dwg_Entity_LINE **|struct _dwg_entity_LINE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LOAD = {"_p_p__dwg_entity_LOAD", "Dwg_Entity_LOAD **|struct _dwg_entity_LOAD **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_LWPOLYLINE = {"_p_p__dwg_entity_LWPOLYLINE", "Dwg_Entity_LWPOLYLINE **|struct _dwg_entity_LWPOLYLINE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_MESH = {"_p_p__dwg_entity_MESH", "Dwg_Entity_MESH **|struct _dwg_entity_MESH **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_MINSERT = {"_p_p__dwg_entity_MINSERT", "Dwg_Entity_MINSERT **|struct _dwg_entity_MINSERT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_MLINE = {"_p_p__dwg_entity_MLINE", "Dwg_Entity_MLINE **|struct _dwg_entity_MLINE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_MTEXT = {"_p_p__dwg_entity_MTEXT", "Dwg_Entity_MTEXT **|struct _dwg_entity_MTEXT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_MULTILEADER = {"_p_p__dwg_entity_MULTILEADER", "Dwg_Entity_MULTILEADER **|struct _dwg_entity_MULTILEADER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_OLE2FRAME = {"_p_p__dwg_entity_OLE2FRAME", "Dwg_Entity_OLE2FRAME **|struct _dwg_entity_OLE2FRAME **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_OLEFRAME = {"_p_p__dwg_entity_OLEFRAME", "Dwg_Entity_OLEFRAME **|struct _dwg_entity_OLEFRAME **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_PLANESURFACE = {"_p_p__dwg_entity_PLANESURFACE", "Dwg_Entity_PLANESURFACE **|struct _dwg_entity_PLANESURFACE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POINT = {"_p_p__dwg_entity_POINT", "Dwg_Entity_POINT **|struct _dwg_entity_POINT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POINTCLOUD = {"_p_p__dwg_entity_POINTCLOUD", "Dwg_Entity_POINTCLOUD **|struct _dwg_entity_POINTCLOUD **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POINTCLOUDEX = {"_p_p__dwg_entity_POINTCLOUDEX", "Dwg_Entity_POINTCLOUDEX **|struct _dwg_entity_POINTCLOUDEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POLYLINE_2D = {"_p_p__dwg_entity_POLYLINE_2D", "Dwg_Entity_POLYLINE_2D **|struct _dwg_entity_POLYLINE_2D **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POLYLINE_3D = {"_p_p__dwg_entity_POLYLINE_3D", "Dwg_Entity_POLYLINE_3D **|struct _dwg_entity_POLYLINE_3D **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POLYLINE_MESH = {"_p_p__dwg_entity_POLYLINE_MESH", "Dwg_Entity_POLYLINE_MESH **|struct _dwg_entity_POLYLINE_MESH **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_POLYLINE_PFACE = {"_p_p__dwg_entity_POLYLINE_PFACE", "Dwg_Entity_POLYLINE_PFACE **|struct _dwg_entity_POLYLINE_PFACE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_PROXY_ENTITY = {"_p_p__dwg_entity_PROXY_ENTITY", "Dwg_Entity_PROXY_ENTITY **|struct _dwg_entity_PROXY_ENTITY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_RAY = {"_p_p__dwg_entity_RAY", "Dwg_Entity_RAY **|Dwg_Entity_XLINE **|struct _dwg_entity_RAY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_REPEAT = {"_p_p__dwg_entity_REPEAT", "Dwg_Entity_REPEAT **|struct _dwg_entity_REPEAT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_SECTIONOBJECT = {"_p_p__dwg_entity_SECTIONOBJECT", "Dwg_Entity_SECTIONOBJECT **|struct _dwg_entity_SECTIONOBJECT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_SEQEND = {"_p_p__dwg_entity_SEQEND", "Dwg_Entity_SEQEND **|struct _dwg_entity_SEQEND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_SHAPE = {"_p_p__dwg_entity_SHAPE", "Dwg_Entity_SHAPE **|struct _dwg_entity_SHAPE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_SOLID = {"_p_p__dwg_entity_SOLID", "Dwg_Entity_SOLID **|struct _dwg_entity_SOLID **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_SPLINE = {"_p_p__dwg_entity_SPLINE", "Dwg_Entity_SPLINE **|struct _dwg_entity_SPLINE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_TEXT = {"_p_p__dwg_entity_TEXT", "Dwg_Entity_TEXT **|struct _dwg_entity_TEXT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_TOLERANCE = {"_p_p__dwg_entity_TOLERANCE", "Dwg_Entity_TOLERANCE **|struct _dwg_entity_TOLERANCE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_TRACE = {"_p_p__dwg_entity_TRACE", "Dwg_Entity_TRACE **|struct _dwg_entity_TRACE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_UNKNOWN_ENT = {"_p_p__dwg_entity_UNKNOWN_ENT", "Dwg_Entity_UNKNOWN_ENT **|struct _dwg_entity_UNKNOWN_ENT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_VERTEX_2D = {"_p_p__dwg_entity_VERTEX_2D", "Dwg_Entity_VERTEX_2D **|struct _dwg_entity_VERTEX_2D **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_VERTEX_3D = {"_p_p__dwg_entity_VERTEX_3D", "Dwg_Entity_VERTEX_3D **|Dwg_Entity_VERTEX_MESH **|Dwg_Entity_VERTEX_PFACE **|struct _dwg_entity_VERTEX_3D **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_VERTEX_PFACE_FACE = {"_p_p__dwg_entity_VERTEX_PFACE_FACE", "Dwg_Entity_VERTEX_PFACE_FACE **|struct _dwg_entity_VERTEX_PFACE_FACE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_VIEWPORT = {"_p_p__dwg_entity_VIEWPORT", "Dwg_Entity_VIEWPORT **|struct _dwg_entity_VIEWPORT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_entity_WIPEOUT = {"_p_p__dwg_entity_WIPEOUT", "Dwg_Entity_WIPEOUT **|struct _dwg_entity_WIPEOUT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_BOOLEAN_CLASS = {"_p_p__dwg_object_ACSH_BOOLEAN_CLASS", "Dwg_Object_ACSH_BOOLEAN_CLASS **|struct _dwg_object_ACSH_BOOLEAN_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_BOX_CLASS = {"_p_p__dwg_object_ACSH_BOX_CLASS", "Dwg_Object_ACSH_BOX_CLASS **|struct _dwg_object_ACSH_BOX_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_BREP_CLASS = {"_p_p__dwg_object_ACSH_BREP_CLASS", "Dwg_Object_ACSH_BREP_CLASS **|struct _dwg_object_ACSH_BREP_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_CHAMFER_CLASS = {"_p_p__dwg_object_ACSH_CHAMFER_CLASS", "Dwg_Object_ACSH_CHAMFER_CLASS **|struct _dwg_object_ACSH_CHAMFER_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_CONE_CLASS = {"_p_p__dwg_object_ACSH_CONE_CLASS", "Dwg_Object_ACSH_CONE_CLASS **|struct _dwg_object_ACSH_CONE_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_CYLINDER_CLASS = {"_p_p__dwg_object_ACSH_CYLINDER_CLASS", "Dwg_Object_ACSH_CYLINDER_CLASS **|struct _dwg_object_ACSH_CYLINDER_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_FILLET_CLASS = {"_p_p__dwg_object_ACSH_FILLET_CLASS", "Dwg_Object_ACSH_FILLET_CLASS **|struct _dwg_object_ACSH_FILLET_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_HISTORY_CLASS = {"_p_p__dwg_object_ACSH_HISTORY_CLASS", "Dwg_Object_ACSH_HISTORY_CLASS **|struct _dwg_object_ACSH_HISTORY_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_PYRAMID_CLASS = {"_p_p__dwg_object_ACSH_PYRAMID_CLASS", "Dwg_Object_ACSH_PYRAMID_CLASS **|struct _dwg_object_ACSH_PYRAMID_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_SPHERE_CLASS = {"_p_p__dwg_object_ACSH_SPHERE_CLASS", "Dwg_Object_ACSH_SPHERE_CLASS **|struct _dwg_object_ACSH_SPHERE_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_TORUS_CLASS = {"_p_p__dwg_object_ACSH_TORUS_CLASS", "Dwg_Object_ACSH_TORUS_CLASS **|struct _dwg_object_ACSH_TORUS_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ACSH_WEDGE_CLASS = {"_p_p__dwg_object_ACSH_WEDGE_CLASS", "Dwg_Object_ACSH_WEDGE_CLASS **|struct _dwg_object_ACSH_WEDGE_CLASS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ALDIMOBJECTCONTEXTDATA = {"_p_p__dwg_object_ALDIMOBJECTCONTEXTDATA", "Dwg_Object_ALDIMOBJECTCONTEXTDATA **|struct _dwg_object_ALDIMOBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_APPID = {"_p_p__dwg_object_APPID", "Dwg_Object_APPID **|struct _dwg_object_APPID **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_APPID_CONTROL = {"_p_p__dwg_object_APPID_CONTROL", "Dwg_Object_APPID_CONTROL **|struct _dwg_object_APPID_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOC2DCONSTRAINTGROUP = {"_p_p__dwg_object_ASSOC2DCONSTRAINTGROUP", "Dwg_Object_ASSOC2DCONSTRAINTGROUP **|struct _dwg_object_ASSOC2DCONSTRAINTGROUP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCACTION = {"_p_p__dwg_object_ASSOCACTION", "Dwg_Object_ASSOCACTION **|struct _dwg_object_ASSOCACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCACTIONPARAM = {"_p_p__dwg_object_ASSOCACTIONPARAM", "Dwg_Object_ASSOCACTIONPARAM **|struct _dwg_object_ASSOCACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCARRAYACTIONBODY = {"_p_p__dwg_object_ASSOCARRAYACTIONBODY", "Dwg_Object_ASSOCARRAYACTIONBODY **|struct _dwg_object_ASSOCARRAYACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCASMBODYACTIONPARAM = {"_p_p__dwg_object_ASSOCASMBODYACTIONPARAM", "Dwg_Object_ASSOCASMBODYACTIONPARAM **|struct _dwg_object_ASSOCASMBODYACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY", "Dwg_Object_ASSOCBLENDSURFACEACTIONBODY **|struct _dwg_object_ASSOCBLENDSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM = {"_p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM", "Dwg_Object_ASSOCCOMPOUNDACTIONPARAM **|struct _dwg_object_ASSOCCOMPOUNDACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCDEPENDENCY = {"_p_p__dwg_object_ASSOCDEPENDENCY", "Dwg_Object_ASSOCDEPENDENCY **|struct _dwg_object_ASSOCDEPENDENCY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCDIMDEPENDENCYBODY = {"_p_p__dwg_object_ASSOCDIMDEPENDENCYBODY", "Dwg_Object_ASSOCDIMDEPENDENCYBODY **|struct _dwg_object_ASSOCDIMDEPENDENCYBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY", "Dwg_Object_ASSOCEXTENDSURFACEACTIONBODY **|struct _dwg_object_ASSOCEXTENDSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY", "Dwg_Object_ASSOCEXTRUDEDSURFACEACTIONBODY **|struct _dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCFACEACTIONPARAM = {"_p_p__dwg_object_ASSOCFACEACTIONPARAM", "Dwg_Object_ASSOCFACEACTIONPARAM **|struct _dwg_object_ASSOCFACEACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY", "Dwg_Object_ASSOCFILLETSURFACEACTIONBODY **|struct _dwg_object_ASSOCFILLETSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCGEOMDEPENDENCY = {"_p_p__dwg_object_ASSOCGEOMDEPENDENCY", "Dwg_Object_ASSOCGEOMDEPENDENCY **|struct _dwg_object_ASSOCGEOMDEPENDENCY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY", "Dwg_Object_ASSOCLOFTEDSURFACEACTIONBODY **|struct _dwg_object_ASSOCLOFTEDSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCNETWORK = {"_p_p__dwg_object_ASSOCNETWORK", "Dwg_Object_ASSOCNETWORK **|struct _dwg_object_ASSOCNETWORK **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY", "Dwg_Object_ASSOCNETWORKSURFACEACTIONBODY **|struct _dwg_object_ASSOCNETWORKSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCOBJECTACTIONPARAM = {"_p_p__dwg_object_ASSOCOBJECTACTIONPARAM", "Dwg_Object_ASSOCOBJECTACTIONPARAM **|struct _dwg_object_ASSOCOBJECTACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY", "Dwg_Object_ASSOCOFFSETSURFACEACTIONBODY **|struct _dwg_object_ASSOCOFFSETSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM = {"_p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM", "Dwg_Object_ASSOCOSNAPPOINTREFACTIONPARAM **|struct _dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY", "Dwg_Object_ASSOCPATCHSURFACEACTIONBODY **|struct _dwg_object_ASSOCPATCHSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCPATHACTIONPARAM = {"_p_p__dwg_object_ASSOCPATHACTIONPARAM", "Dwg_Object_ASSOCPATHACTIONPARAM **|struct _dwg_object_ASSOCPATHACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY", "Dwg_Object_ASSOCPLANESURFACEACTIONBODY **|struct _dwg_object_ASSOCPLANESURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCPOINTREFACTIONPARAM = {"_p_p__dwg_object_ASSOCPOINTREFACTIONPARAM", "Dwg_Object_ASSOCPOINTREFACTIONPARAM **|struct _dwg_object_ASSOCPOINTREFACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY", "Dwg_Object_ASSOCREVOLVEDSURFACEACTIONBODY **|struct _dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY = {"_p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY", "Dwg_Object_ASSOCTRIMSURFACEACTIONBODY **|struct _dwg_object_ASSOCTRIMSURFACEACTIONBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCVALUEDEPENDENCY = {"_p_p__dwg_object_ASSOCVALUEDEPENDENCY", "Dwg_Object_ASSOCVALUEDEPENDENCY **|struct _dwg_object_ASSOCVALUEDEPENDENCY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCVARIABLE = {"_p_p__dwg_object_ASSOCVARIABLE", "Dwg_Object_ASSOCVARIABLE **|struct _dwg_object_ASSOCVARIABLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ASSOCVERTEXACTIONPARAM = {"_p_p__dwg_object_ASSOCVERTEXACTIONPARAM", "Dwg_Object_ASSOCVERTEXACTIONPARAM **|struct _dwg_object_ASSOCVERTEXACTIONPARAM **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLKREFOBJECTCONTEXTDATA = {"_p_p__dwg_object_BLKREFOBJECTCONTEXTDATA", "Dwg_Object_BLKREFOBJECTCONTEXTDATA **|struct _dwg_object_BLKREFOBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER", "Dwg_Object_BLOCKALIGNEDCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKALIGNMENTGRIP = {"_p_p__dwg_object_BLOCKALIGNMENTGRIP", "Dwg_Object_BLOCKALIGNMENTGRIP **|struct _dwg_object_BLOCKALIGNMENTGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKALIGNMENTPARAMETER = {"_p_p__dwg_object_BLOCKALIGNMENTPARAMETER", "Dwg_Object_BLOCKALIGNMENTPARAMETER **|struct _dwg_object_BLOCKALIGNMENTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER", "Dwg_Object_BLOCKANGULARCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKANGULARCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKARRAYACTION = {"_p_p__dwg_object_BLOCKARRAYACTION", "Dwg_Object_BLOCKARRAYACTION **|struct _dwg_object_BLOCKARRAYACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKBASEPOINTPARAMETER = {"_p_p__dwg_object_BLOCKBASEPOINTPARAMETER", "Dwg_Object_BLOCKBASEPOINTPARAMETER **|struct _dwg_object_BLOCKBASEPOINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER", "Dwg_Object_BLOCKDIAMETRICCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKFLIPACTION = {"_p_p__dwg_object_BLOCKFLIPACTION", "Dwg_Object_BLOCKFLIPACTION **|struct _dwg_object_BLOCKFLIPACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKFLIPGRIP = {"_p_p__dwg_object_BLOCKFLIPGRIP", "Dwg_Object_BLOCKFLIPGRIP **|struct _dwg_object_BLOCKFLIPGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKFLIPPARAMETER = {"_p_p__dwg_object_BLOCKFLIPPARAMETER", "Dwg_Object_BLOCKFLIPPARAMETER **|struct _dwg_object_BLOCKFLIPPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT = {"_p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT", "Dwg_Object_BLOCKGRIPLOCATIONCOMPONENT **|struct _dwg_object_BLOCKGRIPLOCATIONCOMPONENT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKHORIZONTALCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER", "Dwg_Object_BLOCKLINEARCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKLINEARCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLINEARGRIP = {"_p_p__dwg_object_BLOCKLINEARGRIP", "Dwg_Object_BLOCKLINEARGRIP **|struct _dwg_object_BLOCKLINEARGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLINEARPARAMETER = {"_p_p__dwg_object_BLOCKLINEARPARAMETER", "Dwg_Object_BLOCKLINEARPARAMETER **|struct _dwg_object_BLOCKLINEARPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLOOKUPACTION = {"_p_p__dwg_object_BLOCKLOOKUPACTION", "Dwg_Object_BLOCKLOOKUPACTION **|struct _dwg_object_BLOCKLOOKUPACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLOOKUPGRIP = {"_p_p__dwg_object_BLOCKLOOKUPGRIP", "Dwg_Object_BLOCKLOOKUPGRIP **|struct _dwg_object_BLOCKLOOKUPGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKLOOKUPPARAMETER = {"_p_p__dwg_object_BLOCKLOOKUPPARAMETER", "Dwg_Object_BLOCKLOOKUPPARAMETER **|struct _dwg_object_BLOCKLOOKUPPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKMOVEACTION = {"_p_p__dwg_object_BLOCKMOVEACTION", "Dwg_Object_BLOCKMOVEACTION **|struct _dwg_object_BLOCKMOVEACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY = {"_p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY", "Dwg_Object_BLOCKPARAMDEPENDENCYBODY **|struct _dwg_object_BLOCKPARAMDEPENDENCYBODY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKPOINTPARAMETER = {"_p_p__dwg_object_BLOCKPOINTPARAMETER", "Dwg_Object_BLOCKPOINTPARAMETER **|struct _dwg_object_BLOCKPOINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKPOLARGRIP = {"_p_p__dwg_object_BLOCKPOLARGRIP", "Dwg_Object_BLOCKPOLARGRIP **|struct _dwg_object_BLOCKPOLARGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKPOLARPARAMETER = {"_p_p__dwg_object_BLOCKPOLARPARAMETER", "Dwg_Object_BLOCKPOLARPARAMETER **|struct _dwg_object_BLOCKPOLARPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKPOLARSTRETCHACTION = {"_p_p__dwg_object_BLOCKPOLARSTRETCHACTION", "Dwg_Object_BLOCKPOLARSTRETCHACTION **|struct _dwg_object_BLOCKPOLARSTRETCHACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKRADIALCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKRADIALCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKREPRESENTATION = {"_p_p__dwg_object_BLOCKREPRESENTATION", "Dwg_Object_BLOCKREPRESENTATION **|struct _dwg_object_BLOCKREPRESENTATION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKROTATEACTION = {"_p_p__dwg_object_BLOCKROTATEACTION", "Dwg_Object_BLOCKROTATEACTION **|struct _dwg_object_BLOCKROTATEACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKROTATIONGRIP = {"_p_p__dwg_object_BLOCKROTATIONGRIP", "Dwg_Object_BLOCKROTATIONGRIP **|struct _dwg_object_BLOCKROTATIONGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKROTATIONPARAMETER = {"_p_p__dwg_object_BLOCKROTATIONPARAMETER", "Dwg_Object_BLOCKROTATIONPARAMETER **|struct _dwg_object_BLOCKROTATIONPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKSCALEACTION = {"_p_p__dwg_object_BLOCKSCALEACTION", "Dwg_Object_BLOCKSCALEACTION **|struct _dwg_object_BLOCKSCALEACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKSTRETCHACTION = {"_p_p__dwg_object_BLOCKSTRETCHACTION", "Dwg_Object_BLOCKSTRETCHACTION **|struct _dwg_object_BLOCKSTRETCHACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKUSERPARAMETER = {"_p_p__dwg_object_BLOCKUSERPARAMETER", "Dwg_Object_BLOCKUSERPARAMETER **|struct _dwg_object_BLOCKUSERPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER = {"_p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER", "Dwg_Object_BLOCKVERTICALCONSTRAINTPARAMETER **|struct _dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKVISIBILITYGRIP = {"_p_p__dwg_object_BLOCKVISIBILITYGRIP", "Dwg_Object_BLOCKVISIBILITYGRIP **|struct _dwg_object_BLOCKVISIBILITYGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKVISIBILITYPARAMETER = {"_p_p__dwg_object_BLOCKVISIBILITYPARAMETER", "Dwg_Object_BLOCKVISIBILITYPARAMETER **|struct _dwg_object_BLOCKVISIBILITYPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKXYGRIP = {"_p_p__dwg_object_BLOCKXYGRIP", "Dwg_Object_BLOCKXYGRIP **|struct _dwg_object_BLOCKXYGRIP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCKXYPARAMETER = {"_p_p__dwg_object_BLOCKXYPARAMETER", "Dwg_Object_BLOCKXYPARAMETER **|struct _dwg_object_BLOCKXYPARAMETER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCK_CONTROL = {"_p_p__dwg_object_BLOCK_CONTROL", "Dwg_Object_BLOCK_CONTROL **|struct _dwg_object_BLOCK_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_BLOCK_HEADER = {"_p_p__dwg_object_BLOCK_HEADER", "Dwg_Object_BLOCK_HEADER **|struct _dwg_object_BLOCK_HEADER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_CELLSTYLEMAP = {"_p_p__dwg_object_CELLSTYLEMAP", "Dwg_Object_CELLSTYLEMAP **|struct _dwg_object_CELLSTYLEMAP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DATALINK = {"_p_p__dwg_object_DATALINK", "Dwg_Object_DATALINK **|struct _dwg_object_DATALINK **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DBCOLOR = {"_p_p__dwg_object_DBCOLOR", "Dwg_Object_DBCOLOR **|struct _dwg_object_DBCOLOR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DETAILVIEWSTYLE = {"_p_p__dwg_object_DETAILVIEWSTYLE", "Dwg_Object_DETAILVIEWSTYLE **|struct _dwg_object_DETAILVIEWSTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DICTIONARY = {"_p_p__dwg_object_DICTIONARY", "Dwg_Object_DICTIONARY **|struct _dwg_object_DICTIONARY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DICTIONARYVAR = {"_p_p__dwg_object_DICTIONARYVAR", "Dwg_Object_DICTIONARYVAR **|struct _dwg_object_DICTIONARYVAR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DICTIONARYWDFLT = {"_p_p__dwg_object_DICTIONARYWDFLT", "Dwg_Object_DICTIONARYWDFLT **|struct _dwg_object_DICTIONARYWDFLT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DIMSTYLE = {"_p_p__dwg_object_DIMSTYLE", "Dwg_Object_DIMSTYLE **|struct _dwg_object_DIMSTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DIMSTYLE_CONTROL = {"_p_p__dwg_object_DIMSTYLE_CONTROL", "Dwg_Object_DIMSTYLE_CONTROL **|struct _dwg_object_DIMSTYLE_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DUMMY = {"_p_p__dwg_object_DUMMY", "Dwg_Object_DUMMY **|struct _dwg_object_DUMMY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER = {"_p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER", "Dwg_Object_DYNAMICBLOCKPURGEPREVENTER **|struct _dwg_object_DYNAMICBLOCKPURGEPREVENTER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_EVALUATION_GRAPH = {"_p_p__dwg_object_EVALUATION_GRAPH", "Dwg_Object_EVALUATION_GRAPH **|struct _dwg_object_EVALUATION_GRAPH **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_FCFOBJECTCONTEXTDATA = {"_p_p__dwg_object_FCFOBJECTCONTEXTDATA", "Dwg_Object_FCFOBJECTCONTEXTDATA **|struct _dwg_object_FCFOBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_FIELD = {"_p_p__dwg_object_FIELD", "Dwg_Object_FIELD **|struct _dwg_object_FIELD **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_FIELDLIST = {"_p_p__dwg_object_FIELDLIST", "Dwg_Object_FIELDLIST **|struct _dwg_object_FIELDLIST **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_GEODATA = {"_p_p__dwg_object_GEODATA", "Dwg_Object_GEODATA **|struct _dwg_object_GEODATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_GRADIENT_BACKGROUND = {"_p_p__dwg_object_GRADIENT_BACKGROUND", "Dwg_Object_GRADIENT_BACKGROUND **|struct _dwg_object_GRADIENT_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_GROUND_PLANE_BACKGROUND = {"_p_p__dwg_object_GROUND_PLANE_BACKGROUND", "Dwg_Object_GROUND_PLANE_BACKGROUND **|struct _dwg_object_GROUND_PLANE_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_GROUP = {"_p_p__dwg_object_GROUP", "Dwg_Object_GROUP **|struct _dwg_object_GROUP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_IBL_BACKGROUND = {"_p_p__dwg_object_IBL_BACKGROUND", "Dwg_Object_IBL_BACKGROUND **|struct _dwg_object_IBL_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_IDBUFFER = {"_p_p__dwg_object_IDBUFFER", "Dwg_Object_IDBUFFER **|struct _dwg_object_IDBUFFER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_IMAGEDEF = {"_p_p__dwg_object_IMAGEDEF", "Dwg_Object_IMAGEDEF **|struct _dwg_object_IMAGEDEF **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_IMAGEDEF_REACTOR = {"_p_p__dwg_object_IMAGEDEF_REACTOR", "Dwg_Object_IMAGEDEF_REACTOR **|struct _dwg_object_IMAGEDEF_REACTOR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_IMAGE_BACKGROUND = {"_p_p__dwg_object_IMAGE_BACKGROUND", "Dwg_Object_IMAGE_BACKGROUND **|struct _dwg_object_IMAGE_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_INDEX = {"_p_p__dwg_object_INDEX", "Dwg_Object_INDEX **|struct _dwg_object_INDEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LAYER = {"_p_p__dwg_object_LAYER", "Dwg_Object_LAYER **|struct _dwg_object_LAYER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LAYERFILTER = {"_p_p__dwg_object_LAYERFILTER", "Dwg_Object_LAYERFILTER **|struct _dwg_object_LAYERFILTER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LAYER_CONTROL = {"_p_p__dwg_object_LAYER_CONTROL", "Dwg_Object_LAYER_CONTROL **|struct _dwg_object_LAYER_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LAYER_INDEX = {"_p_p__dwg_object_LAYER_INDEX", "Dwg_Object_LAYER_INDEX **|struct _dwg_object_LAYER_INDEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LAYOUT = {"_p_p__dwg_object_LAYOUT", "Dwg_Object_LAYOUT **|struct _dwg_object_LAYOUT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LEADEROBJECTCONTEXTDATA = {"_p_p__dwg_object_LEADEROBJECTCONTEXTDATA", "Dwg_Object_LEADEROBJECTCONTEXTDATA **|struct _dwg_object_LEADEROBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LIGHTLIST = {"_p_p__dwg_object_LIGHTLIST", "Dwg_Object_LIGHTLIST **|struct _dwg_object_LIGHTLIST **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LONG_TRANSACTION = {"_p_p__dwg_object_LONG_TRANSACTION", "Dwg_Object_LONG_TRANSACTION **|struct _dwg_object_LONG_TRANSACTION **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LTYPE = {"_p_p__dwg_object_LTYPE", "Dwg_Object_LTYPE **|struct _dwg_object_LTYPE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_LTYPE_CONTROL = {"_p_p__dwg_object_LTYPE_CONTROL", "Dwg_Object_LTYPE_CONTROL **|struct _dwg_object_LTYPE_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_MATERIAL = {"_p_p__dwg_object_MATERIAL", "Dwg_Object_MATERIAL **|struct _dwg_object_MATERIAL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_MENTALRAYRENDERSETTINGS = {"_p_p__dwg_object_MENTALRAYRENDERSETTINGS", "Dwg_Object_MENTALRAYRENDERSETTINGS **|struct _dwg_object_MENTALRAYRENDERSETTINGS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_MLEADERSTYLE = {"_p_p__dwg_object_MLEADERSTYLE", "Dwg_Object_MLEADERSTYLE **|struct _dwg_object_MLEADERSTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_MLINESTYLE = {"_p_p__dwg_object_MLINESTYLE", "Dwg_Object_MLINESTYLE **|struct _dwg_object_MLINESTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_MTEXTOBJECTCONTEXTDATA = {"_p_p__dwg_object_MTEXTOBJECTCONTEXTDATA", "Dwg_Object_MTEXTOBJECTCONTEXTDATA **|struct _dwg_object_MTEXTOBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_OBJECT_PTR = {"_p_p__dwg_object_OBJECT_PTR", "Dwg_Object_OBJECT_PTR **|struct _dwg_object_OBJECT_PTR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_PARTIAL_VIEWING_INDEX = {"_p_p__dwg_object_PARTIAL_VIEWING_INDEX", "Dwg_Object_PARTIAL_VIEWING_INDEX **|struct _dwg_object_PARTIAL_VIEWING_INDEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_PLACEHOLDER = {"_p_p__dwg_object_PLACEHOLDER", "Dwg_Object_PLACEHOLDER **|struct _dwg_object_PLACEHOLDER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_PLOTSETTINGS = {"_p_p__dwg_object_PLOTSETTINGS", "Dwg_Object_PLOTSETTINGS **|struct _dwg_object_PLOTSETTINGS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_POINTCLOUDCOLORMAP = {"_p_p__dwg_object_POINTCLOUDCOLORMAP", "Dwg_Object_POINTCLOUDCOLORMAP **|struct _dwg_object_POINTCLOUDCOLORMAP **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_POINTCLOUDDEF = {"_p_p__dwg_object_POINTCLOUDDEF", "Dwg_Object_POINTCLOUDDEF **|struct _dwg_object_POINTCLOUDDEF **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_POINTCLOUDDEFEX = {"_p_p__dwg_object_POINTCLOUDDEFEX", "Dwg_Object_POINTCLOUDDEFEX **|struct _dwg_object_POINTCLOUDDEFEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR = {"_p_p__dwg_object_POINTCLOUDDEF_REACTOR", "Dwg_Object_POINTCLOUDDEF_REACTOR **|struct _dwg_object_POINTCLOUDDEF_REACTOR **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX = {"_p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX", "Dwg_Object_POINTCLOUDDEF_REACTOR_EX **|struct _dwg_object_POINTCLOUDDEF_REACTOR_EX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_PROXY_OBJECT = {"_p_p__dwg_object_PROXY_OBJECT", "Dwg_Object_PROXY_OBJECT **|struct _dwg_object_PROXY_OBJECT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RAPIDRTRENDERSETTINGS = {"_p_p__dwg_object_RAPIDRTRENDERSETTINGS", "Dwg_Object_RAPIDRTRENDERSETTINGS **|struct _dwg_object_RAPIDRTRENDERSETTINGS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RASTERVARIABLES = {"_p_p__dwg_object_RASTERVARIABLES", "Dwg_Object_RASTERVARIABLES **|struct _dwg_object_RASTERVARIABLES **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RENDERENTRY = {"_p_p__dwg_object_RENDERENTRY", "Dwg_Object_RENDERENTRY **|struct _dwg_object_RENDERENTRY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RENDERENVIRONMENT = {"_p_p__dwg_object_RENDERENVIRONMENT", "Dwg_Object_RENDERENVIRONMENT **|struct _dwg_object_RENDERENVIRONMENT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RENDERGLOBAL = {"_p_p__dwg_object_RENDERGLOBAL", "Dwg_Object_RENDERGLOBAL **|struct _dwg_object_RENDERGLOBAL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_RENDERSETTINGS = {"_p_p__dwg_object_RENDERSETTINGS", "Dwg_Object_RENDERSETTINGS **|struct _dwg_object_RENDERSETTINGS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SCALE = {"_p_p__dwg_object_SCALE", "Dwg_Object_SCALE **|struct _dwg_object_SCALE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SECTIONVIEWSTYLE = {"_p_p__dwg_object_SECTIONVIEWSTYLE", "Dwg_Object_SECTIONVIEWSTYLE **|struct _dwg_object_SECTIONVIEWSTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SECTION_MANAGER = {"_p_p__dwg_object_SECTION_MANAGER", "Dwg_Object_SECTION_MANAGER **|struct _dwg_object_SECTION_MANAGER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SECTION_SETTINGS = {"_p_p__dwg_object_SECTION_SETTINGS", "Dwg_Object_SECTION_SETTINGS **|struct _dwg_object_SECTION_SETTINGS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SKYLIGHT_BACKGROUND = {"_p_p__dwg_object_SKYLIGHT_BACKGROUND", "Dwg_Object_SKYLIGHT_BACKGROUND **|struct _dwg_object_SKYLIGHT_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SOLID_BACKGROUND = {"_p_p__dwg_object_SOLID_BACKGROUND", "Dwg_Object_SOLID_BACKGROUND **|struct _dwg_object_SOLID_BACKGROUND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SORTENTSTABLE = {"_p_p__dwg_object_SORTENTSTABLE", "Dwg_Object_SORTENTSTABLE **|struct _dwg_object_SORTENTSTABLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SPATIAL_FILTER = {"_p_p__dwg_object_SPATIAL_FILTER", "Dwg_Object_SPATIAL_FILTER **|struct _dwg_object_SPATIAL_FILTER **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SPATIAL_INDEX = {"_p_p__dwg_object_SPATIAL_INDEX", "Dwg_Object_SPATIAL_INDEX **|struct _dwg_object_SPATIAL_INDEX **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_STYLE = {"_p_p__dwg_object_STYLE", "Dwg_Object_STYLE **|struct _dwg_object_STYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_STYLE_CONTROL = {"_p_p__dwg_object_STYLE_CONTROL", "Dwg_Object_STYLE_CONTROL **|struct _dwg_object_STYLE_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_SUN = {"_p_p__dwg_object_SUN", "Dwg_Object_SUN **|struct _dwg_object_SUN **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_TABLEGEOMETRY = {"_p_p__dwg_object_TABLEGEOMETRY", "Dwg_Object_TABLEGEOMETRY **|struct _dwg_object_TABLEGEOMETRY **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_TABLESTYLE = {"_p_p__dwg_object_TABLESTYLE", "Dwg_Object_TABLESTYLE **|struct _dwg_object_TABLESTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_TEXTOBJECTCONTEXTDATA = {"_p_p__dwg_object_TEXTOBJECTCONTEXTDATA", "Dwg_Object_TEXTOBJECTCONTEXTDATA **|struct _dwg_object_TEXTOBJECTCONTEXTDATA **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_UCS = {"_p_p__dwg_object_UCS", "Dwg_Object_UCS **|struct _dwg_object_UCS **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_UCS_CONTROL = {"_p_p__dwg_object_UCS_CONTROL", "Dwg_Object_UCS_CONTROL **|struct _dwg_object_UCS_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_UNKNOWN_OBJ = {"_p_p__dwg_object_UNKNOWN_OBJ", "Dwg_Object_UNKNOWN_OBJ **|struct _dwg_object_UNKNOWN_OBJ **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VBA_PROJECT = {"_p_p__dwg_object_VBA_PROJECT", "Dwg_Object_VBA_PROJECT **|struct _dwg_object_VBA_PROJECT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VIEW = {"_p_p__dwg_object_VIEW", "Dwg_Object_VIEW **|struct _dwg_object_VIEW **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VIEW_CONTROL = {"_p_p__dwg_object_VIEW_CONTROL", "Dwg_Object_VIEW_CONTROL **|struct _dwg_object_VIEW_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VISUALSTYLE = {"_p_p__dwg_object_VISUALSTYLE", "Dwg_Object_VISUALSTYLE **|struct _dwg_object_VISUALSTYLE **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VPORT = {"_p_p__dwg_object_VPORT", "Dwg_Object_VPORT **|struct _dwg_object_VPORT **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VPORT_CONTROL = {"_p_p__dwg_object_VPORT_CONTROL", "Dwg_Object_VPORT_CONTROL **|struct _dwg_object_VPORT_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VX_CONTROL = {"_p_p__dwg_object_VX_CONTROL", "Dwg_Object_VX_CONTROL **|struct _dwg_object_VX_CONTROL **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_VX_TABLE_RECORD = {"_p_p__dwg_object_VX_TABLE_RECORD", "Dwg_Object_VX_TABLE_RECORD **|struct _dwg_object_VX_TABLE_RECORD **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_WIPEOUTVARIABLES = {"_p_p__dwg_object_WIPEOUTVARIABLES", "Dwg_Object_WIPEOUTVARIABLES **|struct _dwg_object_WIPEOUTVARIABLES **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_XRECORD = {"_p_p__dwg_object_XRECORD", "Dwg_Object_XRECORD **|struct _dwg_object_XRECORD **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_entity = {"_p_p__dwg_object_entity", "Dwg_Object_Entity **|struct _dwg_object_entity **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_object_ref = {"_p_p__dwg_object_ref", "BITCODE_H *|Dwg_Object_Ref **|struct _dwg_object_ref **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__dwg_section = {"_p_p__dwg_section", "Dwg_Section **|struct _dwg_section **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "BITCODE_D2T *|BITCODE_TV *|char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_r2007_file_header = {"_p_r2007_file_header", "Dwg_R2007_Header *|struct r2007_file_header *|r2007_file_header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rgbpalette = {"_p_rgbpalette", "Dwg_RGB_Palette *|struct rgbpalette *|rgbpalette *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "BITCODE_BSd *|BITCODE_RSd *|int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "BITCODE_RCd *|int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "BITCODE_3B *|BITCODE_4BITS *|BITCODE_B *|BITCODE_BB *|BITCODE_RC *|BITCODE_RCu *|BITCODE_RCx *|BITCODE_TF|uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "BITCODE_BL *|BITCODE_BLx *|BITCODE_MS *|BITCODE_RL *|BITCODE_RLx *|uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "BITCODE_BLL *|BITCODE_HV *|BITCODE_RLL *|BITCODE_RLLx *|BITCODE_UMC *|uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "BITCODE_BS *|BITCODE_BSx *|BITCODE_RS *|BITCODE_RSx *|BITCODE_TU|dwg_wchar_t *|uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_DWG_CLASS_STABILITY,
  &_swigt__p_DWG_COLOR_METHOD,
  &_swigt__p_DWG_ENTITY_SECTIONS,
  &_swigt__p_DWG_ERROR,
  &_swigt__p_DWG_HDL_CODE,
  &_swigt__p_DWG_OBJECT_SUPERTYPE,
  &_swigt__p_DWG_OBJECT_TYPE,
  &_swigt__p_DWG_OBJECT_TYPE_R11,
  &_swigt__p_DWG_SECTION_TYPE,
  &_swigt__p_DWG_SECTION_TYPE_R11,
  &_swigt__p_DWG_SECTION_TYPE_R13,
  &_swigt__p_DWG_VERSION_TYPE,
  &_swigt__p_Dwg_Section_Info,
  &_swigt__p_Dwg_Section_InfoHdr,
  &_swigt__p_RESBUF_VALUE_TYPE,
  &_swigt__p__dwg_3DSOLID_material,
  &_swigt__p__dwg_3DSOLID_silhouette,
  &_swigt__p__dwg_3DSOLID_wire,
  &_swigt__p__dwg_ACSH_HistoryNode,
  &_swigt__p__dwg_ACSH_SubentColor,
  &_swigt__p__dwg_ACSH_SubentMaterial,
  &_swigt__p__dwg_ACTIONBODY,
  &_swigt__p__dwg_ARRAYITEMLOCATOR,
  &_swigt__p__dwg_ASSOCACTIONBODY_action,
  &_swigt__p__dwg_ASSOCACTION_Deps,
  &_swigt__p__dwg_ASSOCARRAYITEM,
  &_swigt__p__dwg_ASSOCPARAMBASEDACTIONBODY,
  &_swigt__p__dwg_ASSOCSURFACEACTIONBODY,
  &_swigt__p__dwg_AcDbMTextObjectEmbedded,
  &_swigt__p__dwg_AcDs,
  &_swigt__p__dwg_AcDs_Data,
  &_swigt__p__dwg_AcDs_DataBlob,
  &_swigt__p__dwg_AcDs_DataBlob01,
  &_swigt__p__dwg_AcDs_DataBlobRef,
  &_swigt__p__dwg_AcDs_DataBlobRef_Page,
  &_swigt__p__dwg_AcDs_DataIndex,
  &_swigt__p__dwg_AcDs_DataIndex_Entry,
  &_swigt__p__dwg_AcDs_Data_Record,
  &_swigt__p__dwg_AcDs_Data_RecordHdr,
  &_swigt__p__dwg_AcDs_Schema,
  &_swigt__p__dwg_AcDs_SchemaData,
  &_swigt__p__dwg_AcDs_SchemaData_UProp,
  &_swigt__p__dwg_AcDs_SchemaIndex,
  &_swigt__p__dwg_AcDs_SchemaIndex_Prop,
  &_swigt__p__dwg_AcDs_Schema_Prop,
  &_swigt__p__dwg_AcDs_Search,
  &_swigt__p__dwg_AcDs_Search_Data,
  &_swigt__p__dwg_AcDs_Search_IdIdx,
  &_swigt__p__dwg_AcDs_Search_IdIdxs,
  &_swigt__p__dwg_AcDs_Segment,
  &_swigt__p__dwg_AcDs_SegmentIndex,
  &_swigt__p__dwg_BLOCKACTION_connectionpts,
  &_swigt__p__dwg_BLOCKLOOKUPACTION_lut,
  &_swigt__p__dwg_BLOCKPARAMETER_PropInfo,
  &_swigt__p__dwg_BLOCKPARAMETER_connection,
  &_swigt__p__dwg_BLOCKPARAMVALUESET,
  &_swigt__p__dwg_BLOCKSTRETCHACTION_codes,
  &_swigt__p__dwg_BLOCKSTRETCHACTION_handles,
  &_swigt__p__dwg_BLOCKVISIBILITYPARAMETER_state,
  &_swigt__p__dwg_COMPOUNDOBJECTID,
  &_swigt__p__dwg_CONSTRAINTGROUPNODE,
  &_swigt__p__dwg_CONTEXTDATA_dict,
  &_swigt__p__dwg_CONTEXTDATA_submgr,
  &_swigt__p__dwg_CellContentGeometry,
  &_swigt__p__dwg_CellStyle,
  &_swigt__p__dwg_ColorRamp,
  &_swigt__p__dwg_ContentFormat,
  &_swigt__p__dwg_DATALINK_customdata,
  &_swigt__p__dwg_DATATABLE_column,
  &_swigt__p__dwg_DATATABLE_row,
  &_swigt__p__dwg_DIMASSOC_Ref,
  &_swigt__p__dwg_DIMENSION_common,
  &_swigt__p__dwg_EVAL_Edge,
  &_swigt__p__dwg_EVAL_Node,
  &_swigt__p__dwg_EvalExpr,
  &_swigt__p__dwg_EvalExpr_value,
  &_swigt__p__dwg_EvalVariant,
  &_swigt__p__dwg_EvalVariant_u,
  &_swigt__p__dwg_FIELD_ChildValue,
  &_swigt__p__dwg_FileDepList_Files,
  &_swigt__p__dwg_FormattedTableData,
  &_swigt__p__dwg_FormattedTableMerged,
  &_swigt__p__dwg_GEODATA_meshface,
  &_swigt__p__dwg_GEODATA_meshpt,
  &_swigt__p__dwg_GridFormat,
  &_swigt__p__dwg_HATCH_Color,
  &_swigt__p__dwg_HATCH_ControlPoint,
  &_swigt__p__dwg_HATCH_DefLine,
  &_swigt__p__dwg_HATCH_Path,
  &_swigt__p__dwg_HATCH_PathSeg,
  &_swigt__p__dwg_HATCH_PolylinePath,
  &_swigt__p__dwg_LAYER_entry,
  &_swigt__p__dwg_LEADER_ArrowHead,
  &_swigt__p__dwg_LEADER_BlockLabel,
  &_swigt__p__dwg_LEADER_Break,
  &_swigt__p__dwg_LEADER_Line,
  &_swigt__p__dwg_LEADER_Node,
  &_swigt__p__dwg_LIGHTLIST_light,
  &_swigt__p__dwg_LTYPE_dash,
  &_swigt__p__dwg_LWPOLYLINE_width,
  &_swigt__p__dwg_LinkedData,
  &_swigt__p__dwg_LinkedTableData,
  &_swigt__p__dwg_MATERIAL_color,
  &_swigt__p__dwg_MATERIAL_gentexture,
  &_swigt__p__dwg_MATERIAL_mapper,
  &_swigt__p__dwg_MESH_edge,
  &_swigt__p__dwg_MLEADER_AnnotContext,
  &_swigt__p__dwg_MLEADER_Content,
  &_swigt__p__dwg_MLEADER_Content_Block,
  &_swigt__p__dwg_MLEADER_Content_MText,
  &_swigt__p__dwg_MLINESTYLE_line,
  &_swigt__p__dwg_MLINESTYLE_line_lt,
  &_swigt__p__dwg_MLINE_line,
  &_swigt__p__dwg_MLINE_vertex,
  &_swigt__p__dwg_OCD_Dimension,
  &_swigt__p__dwg_PARTIAL_VIEWING_INDEX_Entry,
  &_swigt__p__dwg_POINTCLOUDCOLORMAP_Ramp,
  &_swigt__p__dwg_POINTCLOUDEX_Croppings,
  &_swigt__p__dwg_POINTCLOUD_Clippings,
  &_swigt__p__dwg_POINTCLOUD_IntensityStyle,
  &_swigt__p__dwg_PROXY_LWPOLYLINE,
  &_swigt__p__dwg_R2004_Header,
  &_swigt__p__dwg_SECTION_geometrysettings,
  &_swigt__p__dwg_SECTION_typesettings,
  &_swigt__p__dwg_SPLINE_control_point,
  &_swigt__p__dwg_SUNSTUDY_Dates,
  &_swigt__p__dwg_SummaryInfo_Property,
  &_swigt__p__dwg_TABLEGEOMETRY_Cell,
  &_swigt__p__dwg_TABLESTYLE_CellStyle,
  &_swigt__p__dwg_TABLESTYLE_border,
  &_swigt__p__dwg_TABLESTYLE_rowstyles,
  &_swigt__p__dwg_TABLE_AttrDef,
  &_swigt__p__dwg_TABLE_BreakHeight,
  &_swigt__p__dwg_TABLE_BreakRow,
  &_swigt__p__dwg_TABLE_Cell,
  &_swigt__p__dwg_TABLE_CustomDataItem,
  &_swigt__p__dwg_TABLE_value,
  &_swigt__p__dwg_TableCell,
  &_swigt__p__dwg_TableCellContent,
  &_swigt__p__dwg_TableCellContent_Attr,
  &_swigt__p__dwg_TableDataColumn,
  &_swigt__p__dwg_TableRow,
  &_swigt__p__dwg_UCS_orthopts,
  &_swigt__p__dwg_VALUEPARAM,
  &_swigt__p__dwg_VALUEPARAM_vars,
  &_swigt__p__dwg_abstractentity_UNDERLAY,
  &_swigt__p__dwg_abstractobject_ASSOCARRAYPARAMETERS,
  &_swigt__p__dwg_abstractobject_UNDERLAYDEFINITION,
  &_swigt__p__dwg_appinfo,
  &_swigt__p__dwg_appinfohistory,
  &_swigt__p__dwg_auxheader,
  &_swigt__p__dwg_binary_chunk,
  &_swigt__p__dwg_binary_chunk_u,
  &_swigt__p__dwg_bitcode_2bd,
  &_swigt__p__dwg_bitcode_2rd,
  &_swigt__p__dwg_bitcode_3bd,
  &_swigt__p__dwg_bitcode_3rd,
  &_swigt__p__dwg_chain,
  &_swigt__p__dwg_class,
  &_swigt__p__dwg_color,
  &_swigt__p__dwg_entity_3DFACE,
  &_swigt__p__dwg_entity_3DLINE,
  &_swigt__p__dwg_entity_3DSOLID,
  &_swigt__p__dwg_entity_ALIGNMENTPARAMETERENTITY,
  &_swigt__p__dwg_entity_ARC,
  &_swigt__p__dwg_entity_ARCALIGNEDTEXT,
  &_swigt__p__dwg_entity_ARC_DIMENSION,
  &_swigt__p__dwg_entity_ATTDEF,
  &_swigt__p__dwg_entity_ATTRIB,
  &_swigt__p__dwg_entity_BASEPOINTPARAMETERENTITY,
  &_swigt__p__dwg_entity_BLOCK,
  &_swigt__p__dwg_entity_CAMERA,
  &_swigt__p__dwg_entity_CIRCLE,
  &_swigt__p__dwg_entity_DIMENSION_ALIGNED,
  &_swigt__p__dwg_entity_DIMENSION_ANG2LN,
  &_swigt__p__dwg_entity_DIMENSION_ANG3PT,
  &_swigt__p__dwg_entity_DIMENSION_DIAMETER,
  &_swigt__p__dwg_entity_DIMENSION_LINEAR,
  &_swigt__p__dwg_entity_DIMENSION_ORDINATE,
  &_swigt__p__dwg_entity_DIMENSION_RADIUS,
  &_swigt__p__dwg_entity_ELLIPSE,
  &_swigt__p__dwg_entity_ENDBLK,
  &_swigt__p__dwg_entity_ENDREP,
  &_swigt__p__dwg_entity_EXTRUDEDSURFACE,
  &_swigt__p__dwg_entity_FLIPGRIPENTITY,
  &_swigt__p__dwg_entity_FLIPPARAMETERENTITY,
  &_swigt__p__dwg_entity_GEOPOSITIONMARKER,
  &_swigt__p__dwg_entity_HATCH,
  &_swigt__p__dwg_entity_HELIX,
  &_swigt__p__dwg_entity_IMAGE,
  &_swigt__p__dwg_entity_INSERT,
  &_swigt__p__dwg_entity_JUMP,
  &_swigt__p__dwg_entity_LARGE_RADIAL_DIMENSION,
  &_swigt__p__dwg_entity_LAYOUTPRINTCONFIG,
  &_swigt__p__dwg_entity_LEADER,
  &_swigt__p__dwg_entity_LIGHT,
  &_swigt__p__dwg_entity_LINE,
  &_swigt__p__dwg_entity_LINEARGRIPENTITY,
  &_swigt__p__dwg_entity_LINEARPARAMETERENTITY,
  &_swigt__p__dwg_entity_LOAD,
  &_swigt__p__dwg_entity_LOFTEDSURFACE,
  &_swigt__p__dwg_entity_LWPOLYLINE,
  &_swigt__p__dwg_entity_MESH,
  &_swigt__p__dwg_entity_MINSERT,
  &_swigt__p__dwg_entity_MLINE,
  &_swigt__p__dwg_entity_MPOLYGON,
  &_swigt__p__dwg_entity_MTEXT,
  &_swigt__p__dwg_entity_MULTILEADER,
  &_swigt__p__dwg_entity_NAVISWORKSMODEL,
  &_swigt__p__dwg_entity_NURBSURFACE,
  &_swigt__p__dwg_entity_OLE2FRAME,
  &_swigt__p__dwg_entity_OLEFRAME,
  &_swigt__p__dwg_entity_PLANESURFACE,
  &_swigt__p__dwg_entity_POINT,
  &_swigt__p__dwg_entity_POINTCLOUD,
  &_swigt__p__dwg_entity_POINTCLOUDEX,
  &_swigt__p__dwg_entity_POINTPARAMETERENTITY,
  &_swigt__p__dwg_entity_POLARGRIPENTITY,
  &_swigt__p__dwg_entity_POLYLINE_2D,
  &_swigt__p__dwg_entity_POLYLINE_3D,
  &_swigt__p__dwg_entity_POLYLINE_MESH,
  &_swigt__p__dwg_entity_POLYLINE_PFACE,
  &_swigt__p__dwg_entity_PROXY_ENTITY,
  &_swigt__p__dwg_entity_RAY,
  &_swigt__p__dwg_entity_REPEAT,
  &_swigt__p__dwg_entity_REVOLVEDSURFACE,
  &_swigt__p__dwg_entity_ROTATIONGRIPENTITY,
  &_swigt__p__dwg_entity_ROTATIONPARAMETERENTITY,
  &_swigt__p__dwg_entity_RTEXT,
  &_swigt__p__dwg_entity_SECTIONOBJECT,
  &_swigt__p__dwg_entity_SEQEND,
  &_swigt__p__dwg_entity_SHAPE,
  &_swigt__p__dwg_entity_SOLID,
  &_swigt__p__dwg_entity_SPLINE,
  &_swigt__p__dwg_entity_SWEPTSURFACE,
  &_swigt__p__dwg_entity_TABLE,
  &_swigt__p__dwg_entity_TEXT,
  &_swigt__p__dwg_entity_TOLERANCE,
  &_swigt__p__dwg_entity_TRACE,
  &_swigt__p__dwg_entity_UNKNOWN_ENT,
  &_swigt__p__dwg_entity_VERTEX_2D,
  &_swigt__p__dwg_entity_VERTEX_3D,
  &_swigt__p__dwg_entity_VERTEX_PFACE_FACE,
  &_swigt__p__dwg_entity_VIEWPORT,
  &_swigt__p__dwg_entity_VISIBILITYGRIPENTITY,
  &_swigt__p__dwg_entity_VISIBILITYPARAMETERENTITY,
  &_swigt__p__dwg_entity_WIPEOUT,
  &_swigt__p__dwg_entity_XYGRIPENTITY,
  &_swigt__p__dwg_entity_XYPARAMETERENTITY,
  &_swigt__p__dwg_entity_eed,
  &_swigt__p__dwg_entity_eed_data,
  &_swigt__p__dwg_filedeplist,
  &_swigt__p__dwg_handle,
  &_swigt__p__dwg_header,
  &_swigt__p__dwg_header_variables,
  &_swigt__p__dwg_object,
  &_swigt__p__dwg_object_ACMECOMMANDHISTORY,
  &_swigt__p__dwg_object_ACMESCOPE,
  &_swigt__p__dwg_object_ACMESTATEMGR,
  &_swigt__p__dwg_object_ACSH_BOOLEAN_CLASS,
  &_swigt__p__dwg_object_ACSH_BOX_CLASS,
  &_swigt__p__dwg_object_ACSH_BREP_CLASS,
  &_swigt__p__dwg_object_ACSH_CHAMFER_CLASS,
  &_swigt__p__dwg_object_ACSH_CONE_CLASS,
  &_swigt__p__dwg_object_ACSH_CYLINDER_CLASS,
  &_swigt__p__dwg_object_ACSH_EXTRUSION_CLASS,
  &_swigt__p__dwg_object_ACSH_FILLET_CLASS,
  &_swigt__p__dwg_object_ACSH_HISTORY_CLASS,
  &_swigt__p__dwg_object_ACSH_LOFT_CLASS,
  &_swigt__p__dwg_object_ACSH_PYRAMID_CLASS,
  &_swigt__p__dwg_object_ACSH_REVOLVE_CLASS,
  &_swigt__p__dwg_object_ACSH_SPHERE_CLASS,
  &_swigt__p__dwg_object_ACSH_SWEEP_CLASS,
  &_swigt__p__dwg_object_ACSH_TORUS_CLASS,
  &_swigt__p__dwg_object_ACSH_WEDGE_CLASS,
  &_swigt__p__dwg_object_ALDIMOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_ANGDIMOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_APPID,
  &_swigt__p__dwg_object_APPID_CONTROL,
  &_swigt__p__dwg_object_ASSOC2DCONSTRAINTGROUP,
  &_swigt__p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY,
  &_swigt__p__dwg_object_ASSOCACTION,
  &_swigt__p__dwg_object_ASSOCACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCALIGNEDDIMACTIONBODY,
  &_swigt__p__dwg_object_ASSOCARRAYACTIONBODY,
  &_swigt__p__dwg_object_ASSOCARRAYMODIFYACTIONBODY,
  &_swigt__p__dwg_object_ASSOCASMBODYACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCBLENDSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCCOMPOUNDACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCDEPENDENCY,
  &_swigt__p__dwg_object_ASSOCDIMDEPENDENCYBODY,
  &_swigt__p__dwg_object_ASSOCEDGEACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCEDGECHAMFERACTIONBODY,
  &_swigt__p__dwg_object_ASSOCEDGEFILLETACTIONBODY,
  &_swigt__p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCFACEACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCFILLETSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCGEOMDEPENDENCY,
  &_swigt__p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCMLEADERACTIONBODY,
  &_swigt__p__dwg_object_ASSOCNETWORK,
  &_swigt__p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCOBJECTACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCORDINATEDIMACTIONBODY,
  &_swigt__p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCPATCHSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCPATHACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCPERSSUBENTMANAGER,
  &_swigt__p__dwg_object_ASSOCPLANESURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCPOINTREFACTIONPARAM,
  &_swigt__p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCROTATEDDIMACTIONBODY,
  &_swigt__p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCTRIMSURFACEACTIONBODY,
  &_swigt__p__dwg_object_ASSOCVALUEDEPENDENCY,
  &_swigt__p__dwg_object_ASSOCVARIABLE,
  &_swigt__p__dwg_object_ASSOCVERTEXACTIONPARAM,
  &_swigt__p__dwg_object_BLKREFOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKALIGNMENTGRIP,
  &_swigt__p__dwg_object_BLOCKALIGNMENTPARAMETER,
  &_swigt__p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKARRAYACTION,
  &_swigt__p__dwg_object_BLOCKBASEPOINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKFLIPACTION,
  &_swigt__p__dwg_object_BLOCKFLIPGRIP,
  &_swigt__p__dwg_object_BLOCKFLIPPARAMETER,
  &_swigt__p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT,
  &_swigt__p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKLINEARGRIP,
  &_swigt__p__dwg_object_BLOCKLINEARPARAMETER,
  &_swigt__p__dwg_object_BLOCKLOOKUPACTION,
  &_swigt__p__dwg_object_BLOCKLOOKUPGRIP,
  &_swigt__p__dwg_object_BLOCKLOOKUPPARAMETER,
  &_swigt__p__dwg_object_BLOCKMOVEACTION,
  &_swigt__p__dwg_object_BLOCKPARAMDEPENDENCYBODY,
  &_swigt__p__dwg_object_BLOCKPOINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKPOLARGRIP,
  &_swigt__p__dwg_object_BLOCKPOLARPARAMETER,
  &_swigt__p__dwg_object_BLOCKPOLARSTRETCHACTION,
  &_swigt__p__dwg_object_BLOCKPROPERTIESTABLE,
  &_swigt__p__dwg_object_BLOCKPROPERTIESTABLEGRIP,
  &_swigt__p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKREPRESENTATION,
  &_swigt__p__dwg_object_BLOCKROTATEACTION,
  &_swigt__p__dwg_object_BLOCKROTATIONGRIP,
  &_swigt__p__dwg_object_BLOCKROTATIONPARAMETER,
  &_swigt__p__dwg_object_BLOCKSCALEACTION,
  &_swigt__p__dwg_object_BLOCKSTRETCHACTION,
  &_swigt__p__dwg_object_BLOCKUSERPARAMETER,
  &_swigt__p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER,
  &_swigt__p__dwg_object_BLOCKVISIBILITYGRIP,
  &_swigt__p__dwg_object_BLOCKVISIBILITYPARAMETER,
  &_swigt__p__dwg_object_BLOCKXYGRIP,
  &_swigt__p__dwg_object_BLOCKXYPARAMETER,
  &_swigt__p__dwg_object_BLOCK_CONTROL,
  &_swigt__p__dwg_object_BLOCK_HEADER,
  &_swigt__p__dwg_object_BREAKDATA,
  &_swigt__p__dwg_object_BREAKPOINTREF,
  &_swigt__p__dwg_object_CELLSTYLEMAP,
  &_swigt__p__dwg_object_CONTEXTDATAMANAGER,
  &_swigt__p__dwg_object_CSACDOCUMENTOPTIONS,
  &_swigt__p__dwg_object_CURVEPATH,
  &_swigt__p__dwg_object_DATALINK,
  &_swigt__p__dwg_object_DATATABLE,
  &_swigt__p__dwg_object_DBCOLOR,
  &_swigt__p__dwg_object_DETAILVIEWSTYLE,
  &_swigt__p__dwg_object_DICTIONARY,
  &_swigt__p__dwg_object_DICTIONARYVAR,
  &_swigt__p__dwg_object_DICTIONARYWDFLT,
  &_swigt__p__dwg_object_DIMASSOC,
  &_swigt__p__dwg_object_DIMSTYLE,
  &_swigt__p__dwg_object_DIMSTYLE_CONTROL,
  &_swigt__p__dwg_object_DMDIMOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_DUMMY,
  &_swigt__p__dwg_object_DYNAMICBLOCKPROXYNODE,
  &_swigt__p__dwg_object_DYNAMICBLOCKPURGEPREVENTER,
  &_swigt__p__dwg_object_EVALUATION_GRAPH,
  &_swigt__p__dwg_object_FCFOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_FIELD,
  &_swigt__p__dwg_object_FIELDLIST,
  &_swigt__p__dwg_object_GEODATA,
  &_swigt__p__dwg_object_GEOMAPIMAGE,
  &_swigt__p__dwg_object_GRADIENT_BACKGROUND,
  &_swigt__p__dwg_object_GROUND_PLANE_BACKGROUND,
  &_swigt__p__dwg_object_GROUP,
  &_swigt__p__dwg_object_IBL_BACKGROUND,
  &_swigt__p__dwg_object_IDBUFFER,
  &_swigt__p__dwg_object_IMAGEDEF,
  &_swigt__p__dwg_object_IMAGEDEF_REACTOR,
  &_swigt__p__dwg_object_IMAGE_BACKGROUND,
  &_swigt__p__dwg_object_INDEX,
  &_swigt__p__dwg_object_LAYER,
  &_swigt__p__dwg_object_LAYERFILTER,
  &_swigt__p__dwg_object_LAYER_CONTROL,
  &_swigt__p__dwg_object_LAYER_INDEX,
  &_swigt__p__dwg_object_LAYOUT,
  &_swigt__p__dwg_object_LEADEROBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_LIGHTLIST,
  &_swigt__p__dwg_object_LONG_TRANSACTION,
  &_swigt__p__dwg_object_LTYPE,
  &_swigt__p__dwg_object_LTYPE_CONTROL,
  &_swigt__p__dwg_object_MATERIAL,
  &_swigt__p__dwg_object_MENTALRAYRENDERSETTINGS,
  &_swigt__p__dwg_object_MLEADEROBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_MLEADERSTYLE,
  &_swigt__p__dwg_object_MLINESTYLE,
  &_swigt__p__dwg_object_MOTIONPATH,
  &_swigt__p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_MTEXTOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_NAVISWORKSMODELDEF,
  &_swigt__p__dwg_object_OBJECT_PTR,
  &_swigt__p__dwg_object_ORDDIMOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_PARTIAL_VIEWING_INDEX,
  &_swigt__p__dwg_object_PERSUBENTMGR,
  &_swigt__p__dwg_object_PLACEHOLDER,
  &_swigt__p__dwg_object_PLOTSETTINGS,
  &_swigt__p__dwg_object_POINTCLOUDCOLORMAP,
  &_swigt__p__dwg_object_POINTCLOUDDEF,
  &_swigt__p__dwg_object_POINTCLOUDDEFEX,
  &_swigt__p__dwg_object_POINTCLOUDDEF_REACTOR,
  &_swigt__p__dwg_object_POINTCLOUDDEF_REACTOR_EX,
  &_swigt__p__dwg_object_POINTPATH,
  &_swigt__p__dwg_object_PROXY_OBJECT,
  &_swigt__p__dwg_object_RADIMLGOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_RADIMOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_RAPIDRTRENDERSETTINGS,
  &_swigt__p__dwg_object_RASTERVARIABLES,
  &_swigt__p__dwg_object_RENDERENTRY,
  &_swigt__p__dwg_object_RENDERENVIRONMENT,
  &_swigt__p__dwg_object_RENDERGLOBAL,
  &_swigt__p__dwg_object_RENDERSETTINGS,
  &_swigt__p__dwg_object_SCALE,
  &_swigt__p__dwg_object_SECTIONVIEWSTYLE,
  &_swigt__p__dwg_object_SECTION_MANAGER,
  &_swigt__p__dwg_object_SECTION_SETTINGS,
  &_swigt__p__dwg_object_SKYLIGHT_BACKGROUND,
  &_swigt__p__dwg_object_SOLID_BACKGROUND,
  &_swigt__p__dwg_object_SORTENTSTABLE,
  &_swigt__p__dwg_object_SPATIAL_FILTER,
  &_swigt__p__dwg_object_SPATIAL_INDEX,
  &_swigt__p__dwg_object_STYLE,
  &_swigt__p__dwg_object_STYLE_CONTROL,
  &_swigt__p__dwg_object_SUN,
  &_swigt__p__dwg_object_SUNSTUDY,
  &_swigt__p__dwg_object_TABLECONTENT,
  &_swigt__p__dwg_object_TABLEGEOMETRY,
  &_swigt__p__dwg_object_TABLESTYLE,
  &_swigt__p__dwg_object_TEXTOBJECTCONTEXTDATA,
  &_swigt__p__dwg_object_TVDEVICEPROPERTIES,
  &_swigt__p__dwg_object_UCS,
  &_swigt__p__dwg_object_UCS_CONTROL,
  &_swigt__p__dwg_object_UNKNOWN_OBJ,
  &_swigt__p__dwg_object_VBA_PROJECT,
  &_swigt__p__dwg_object_VIEW,
  &_swigt__p__dwg_object_VIEW_CONTROL,
  &_swigt__p__dwg_object_VISUALSTYLE,
  &_swigt__p__dwg_object_VPORT,
  &_swigt__p__dwg_object_VPORT_CONTROL,
  &_swigt__p__dwg_object_VX_CONTROL,
  &_swigt__p__dwg_object_VX_TABLE_RECORD,
  &_swigt__p__dwg_object_WIPEOUTVARIABLES,
  &_swigt__p__dwg_object_XRECORD,
  &_swigt__p__dwg_object_entity,
  &_swigt__p__dwg_object_entity_tio,
  &_swigt__p__dwg_object_object,
  &_swigt__p__dwg_object_object_tio,
  &_swigt__p__dwg_object_ref,
  &_swigt__p__dwg_object_tio,
  &_swigt__p__dwg_objfreespace,
  &_swigt__p__dwg_resbuf,
  &_swigt__p__dwg_resbuf_value,
  &_swigt__p__dwg_revhistory,
  &_swigt__p__dwg_secondheader,
  &_swigt__p__dwg_secondheader_handles,
  &_swigt__p__dwg_secondheader_sections,
  &_swigt__p__dwg_section,
  &_swigt__p__dwg_security,
  &_swigt__p__dwg_struct,
  &_swigt__p__dwg_struct_fhdr,
  &_swigt__p__dwg_summaryinfo,
  &_swigt__p__dwg_template,
  &_swigt__p__dwg_time_bll,
  &_swigt__p__dwg_vbaproject,
  &_swigt__p__inthash,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_dwg_entity_DIMENSION_common,
  &_swigt__p_dwg_field_name_type_offset,
  &_swigt__p_dwg_obj_ent,
  &_swigt__p_dwg_obj_generic,
  &_swigt__p_dwg_obj_layer,
  &_swigt__p_dwg_obj_obj,
  &_swigt__p_dwg_object,
  &_swigt__p_dwg_versions,
  &_swigt__p_eed_data_t,
  &_swigt__p_eed_data_t_eed_0,
  &_swigt__p_eed_data_t_eed_0_r2007,
  &_swigt__p_eed_data_t_eed_1,
  &_swigt__p_eed_data_t_eed_10,
  &_swigt__p_eed_data_t_eed_2,
  &_swigt__p_eed_data_t_eed_3,
  &_swigt__p_eed_data_t_eed_4,
  &_swigt__p_eed_data_t_eed_40,
  &_swigt__p_eed_data_t_eed_5,
  &_swigt__p_eed_data_t_eed_70,
  &_swigt__p_eed_data_t_eed_71,
  &_swigt__p_int,
  &_swigt__p_long_long,
  &_swigt__p_p__dwg_abstractentity_UNDERLAY,
  &_swigt__p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS,
  &_swigt__p_p__dwg_abstractobject_UNDERLAYDEFINITION,
  &_swigt__p_p__dwg_entity_3DFACE,
  &_swigt__p_p__dwg_entity_3DLINE,
  &_swigt__p_p__dwg_entity_3DSOLID,
  &_swigt__p_p__dwg_entity_ARC,
  &_swigt__p_p__dwg_entity_ARC_DIMENSION,
  &_swigt__p_p__dwg_entity_ATTDEF,
  &_swigt__p_p__dwg_entity_ATTRIB,
  &_swigt__p_p__dwg_entity_BLOCK,
  &_swigt__p_p__dwg_entity_CAMERA,
  &_swigt__p_p__dwg_entity_CIRCLE,
  &_swigt__p_p__dwg_entity_DIMENSION_ALIGNED,
  &_swigt__p_p__dwg_entity_DIMENSION_ANG2LN,
  &_swigt__p_p__dwg_entity_DIMENSION_ANG3PT,
  &_swigt__p_p__dwg_entity_DIMENSION_DIAMETER,
  &_swigt__p_p__dwg_entity_DIMENSION_LINEAR,
  &_swigt__p_p__dwg_entity_DIMENSION_ORDINATE,
  &_swigt__p_p__dwg_entity_DIMENSION_RADIUS,
  &_swigt__p_p__dwg_entity_ELLIPSE,
  &_swigt__p_p__dwg_entity_ENDBLK,
  &_swigt__p_p__dwg_entity_ENDREP,
  &_swigt__p_p__dwg_entity_HATCH,
  &_swigt__p_p__dwg_entity_HELIX,
  &_swigt__p_p__dwg_entity_IMAGE,
  &_swigt__p_p__dwg_entity_INSERT,
  &_swigt__p_p__dwg_entity_JUMP,
  &_swigt__p_p__dwg_entity_LARGE_RADIAL_DIMENSION,
  &_swigt__p_p__dwg_entity_LAYOUTPRINTCONFIG,
  &_swigt__p_p__dwg_entity_LEADER,
  &_swigt__p_p__dwg_entity_LIGHT,
  &_swigt__p_p__dwg_entity_LINE,
  &_swigt__p_p__dwg_entity_LOAD,
  &_swigt__p_p__dwg_entity_LWPOLYLINE,
  &_swigt__p_p__dwg_entity_MESH,
  &_swigt__p_p__dwg_entity_MINSERT,
  &_swigt__p_p__dwg_entity_MLINE,
  &_swigt__p_p__dwg_entity_MTEXT,
  &_swigt__p_p__dwg_entity_MULTILEADER,
  &_swigt__p_p__dwg_entity_OLE2FRAME,
  &_swigt__p_p__dwg_entity_OLEFRAME,
  &_swigt__p_p__dwg_entity_PLANESURFACE,
  &_swigt__p_p__dwg_entity_POINT,
  &_swigt__p_p__dwg_entity_POINTCLOUD,
  &_swigt__p_p__dwg_entity_POINTCLOUDEX,
  &_swigt__p_p__dwg_entity_POLYLINE_2D,
  &_swigt__p_p__dwg_entity_POLYLINE_3D,
  &_swigt__p_p__dwg_entity_POLYLINE_MESH,
  &_swigt__p_p__dwg_entity_POLYLINE_PFACE,
  &_swigt__p_p__dwg_entity_PROXY_ENTITY,
  &_swigt__p_p__dwg_entity_RAY,
  &_swigt__p_p__dwg_entity_REPEAT,
  &_swigt__p_p__dwg_entity_SECTIONOBJECT,
  &_swigt__p_p__dwg_entity_SEQEND,
  &_swigt__p_p__dwg_entity_SHAPE,
  &_swigt__p_p__dwg_entity_SOLID,
  &_swigt__p_p__dwg_entity_SPLINE,
  &_swigt__p_p__dwg_entity_TEXT,
  &_swigt__p_p__dwg_entity_TOLERANCE,
  &_swigt__p_p__dwg_entity_TRACE,
  &_swigt__p_p__dwg_entity_UNKNOWN_ENT,
  &_swigt__p_p__dwg_entity_VERTEX_2D,
  &_swigt__p_p__dwg_entity_VERTEX_3D,
  &_swigt__p_p__dwg_entity_VERTEX_PFACE_FACE,
  &_swigt__p_p__dwg_entity_VIEWPORT,
  &_swigt__p_p__dwg_entity_WIPEOUT,
  &_swigt__p_p__dwg_object_ACSH_BOOLEAN_CLASS,
  &_swigt__p_p__dwg_object_ACSH_BOX_CLASS,
  &_swigt__p_p__dwg_object_ACSH_BREP_CLASS,
  &_swigt__p_p__dwg_object_ACSH_CHAMFER_CLASS,
  &_swigt__p_p__dwg_object_ACSH_CONE_CLASS,
  &_swigt__p_p__dwg_object_ACSH_CYLINDER_CLASS,
  &_swigt__p_p__dwg_object_ACSH_FILLET_CLASS,
  &_swigt__p_p__dwg_object_ACSH_HISTORY_CLASS,
  &_swigt__p_p__dwg_object_ACSH_PYRAMID_CLASS,
  &_swigt__p_p__dwg_object_ACSH_SPHERE_CLASS,
  &_swigt__p_p__dwg_object_ACSH_TORUS_CLASS,
  &_swigt__p_p__dwg_object_ACSH_WEDGE_CLASS,
  &_swigt__p_p__dwg_object_ALDIMOBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_APPID,
  &_swigt__p_p__dwg_object_APPID_CONTROL,
  &_swigt__p_p__dwg_object_ASSOC2DCONSTRAINTGROUP,
  &_swigt__p_p__dwg_object_ASSOCACTION,
  &_swigt__p_p__dwg_object_ASSOCACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCARRAYACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCASMBODYACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCDEPENDENCY,
  &_swigt__p_p__dwg_object_ASSOCDIMDEPENDENCYBODY,
  &_swigt__p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCFACEACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCGEOMDEPENDENCY,
  &_swigt__p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCNETWORK,
  &_swigt__p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCOBJECTACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCPATHACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCPOINTREFACTIONPARAM,
  &_swigt__p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY,
  &_swigt__p_p__dwg_object_ASSOCVALUEDEPENDENCY,
  &_swigt__p_p__dwg_object_ASSOCVARIABLE,
  &_swigt__p_p__dwg_object_ASSOCVERTEXACTIONPARAM,
  &_swigt__p_p__dwg_object_BLKREFOBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKALIGNMENTGRIP,
  &_swigt__p_p__dwg_object_BLOCKALIGNMENTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKARRAYACTION,
  &_swigt__p_p__dwg_object_BLOCKBASEPOINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKFLIPACTION,
  &_swigt__p_p__dwg_object_BLOCKFLIPGRIP,
  &_swigt__p_p__dwg_object_BLOCKFLIPPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT,
  &_swigt__p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKLINEARGRIP,
  &_swigt__p_p__dwg_object_BLOCKLINEARPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKLOOKUPACTION,
  &_swigt__p_p__dwg_object_BLOCKLOOKUPGRIP,
  &_swigt__p_p__dwg_object_BLOCKLOOKUPPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKMOVEACTION,
  &_swigt__p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY,
  &_swigt__p_p__dwg_object_BLOCKPOINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKPOLARGRIP,
  &_swigt__p_p__dwg_object_BLOCKPOLARPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKPOLARSTRETCHACTION,
  &_swigt__p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKREPRESENTATION,
  &_swigt__p_p__dwg_object_BLOCKROTATEACTION,
  &_swigt__p_p__dwg_object_BLOCKROTATIONGRIP,
  &_swigt__p_p__dwg_object_BLOCKROTATIONPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKSCALEACTION,
  &_swigt__p_p__dwg_object_BLOCKSTRETCHACTION,
  &_swigt__p_p__dwg_object_BLOCKUSERPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKVISIBILITYGRIP,
  &_swigt__p_p__dwg_object_BLOCKVISIBILITYPARAMETER,
  &_swigt__p_p__dwg_object_BLOCKXYGRIP,
  &_swigt__p_p__dwg_object_BLOCKXYPARAMETER,
  &_swigt__p_p__dwg_object_BLOCK_CONTROL,
  &_swigt__p_p__dwg_object_BLOCK_HEADER,
  &_swigt__p_p__dwg_object_CELLSTYLEMAP,
  &_swigt__p_p__dwg_object_DATALINK,
  &_swigt__p_p__dwg_object_DBCOLOR,
  &_swigt__p_p__dwg_object_DETAILVIEWSTYLE,
  &_swigt__p_p__dwg_object_DICTIONARY,
  &_swigt__p_p__dwg_object_DICTIONARYVAR,
  &_swigt__p_p__dwg_object_DICTIONARYWDFLT,
  &_swigt__p_p__dwg_object_DIMSTYLE,
  &_swigt__p_p__dwg_object_DIMSTYLE_CONTROL,
  &_swigt__p_p__dwg_object_DUMMY,
  &_swigt__p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER,
  &_swigt__p_p__dwg_object_EVALUATION_GRAPH,
  &_swigt__p_p__dwg_object_FCFOBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_FIELD,
  &_swigt__p_p__dwg_object_FIELDLIST,
  &_swigt__p_p__dwg_object_GEODATA,
  &_swigt__p_p__dwg_object_GRADIENT_BACKGROUND,
  &_swigt__p_p__dwg_object_GROUND_PLANE_BACKGROUND,
  &_swigt__p_p__dwg_object_GROUP,
  &_swigt__p_p__dwg_object_IBL_BACKGROUND,
  &_swigt__p_p__dwg_object_IDBUFFER,
  &_swigt__p_p__dwg_object_IMAGEDEF,
  &_swigt__p_p__dwg_object_IMAGEDEF_REACTOR,
  &_swigt__p_p__dwg_object_IMAGE_BACKGROUND,
  &_swigt__p_p__dwg_object_INDEX,
  &_swigt__p_p__dwg_object_LAYER,
  &_swigt__p_p__dwg_object_LAYERFILTER,
  &_swigt__p_p__dwg_object_LAYER_CONTROL,
  &_swigt__p_p__dwg_object_LAYER_INDEX,
  &_swigt__p_p__dwg_object_LAYOUT,
  &_swigt__p_p__dwg_object_LEADEROBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_LIGHTLIST,
  &_swigt__p_p__dwg_object_LONG_TRANSACTION,
  &_swigt__p_p__dwg_object_LTYPE,
  &_swigt__p_p__dwg_object_LTYPE_CONTROL,
  &_swigt__p_p__dwg_object_MATERIAL,
  &_swigt__p_p__dwg_object_MENTALRAYRENDERSETTINGS,
  &_swigt__p_p__dwg_object_MLEADERSTYLE,
  &_swigt__p_p__dwg_object_MLINESTYLE,
  &_swigt__p_p__dwg_object_MTEXTOBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_OBJECT_PTR,
  &_swigt__p_p__dwg_object_PARTIAL_VIEWING_INDEX,
  &_swigt__p_p__dwg_object_PLACEHOLDER,
  &_swigt__p_p__dwg_object_PLOTSETTINGS,
  &_swigt__p_p__dwg_object_POINTCLOUDCOLORMAP,
  &_swigt__p_p__dwg_object_POINTCLOUDDEF,
  &_swigt__p_p__dwg_object_POINTCLOUDDEFEX,
  &_swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR,
  &_swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX,
  &_swigt__p_p__dwg_object_PROXY_OBJECT,
  &_swigt__p_p__dwg_object_RAPIDRTRENDERSETTINGS,
  &_swigt__p_p__dwg_object_RASTERVARIABLES,
  &_swigt__p_p__dwg_object_RENDERENTRY,
  &_swigt__p_p__dwg_object_RENDERENVIRONMENT,
  &_swigt__p_p__dwg_object_RENDERGLOBAL,
  &_swigt__p_p__dwg_object_RENDERSETTINGS,
  &_swigt__p_p__dwg_object_SCALE,
  &_swigt__p_p__dwg_object_SECTIONVIEWSTYLE,
  &_swigt__p_p__dwg_object_SECTION_MANAGER,
  &_swigt__p_p__dwg_object_SECTION_SETTINGS,
  &_swigt__p_p__dwg_object_SKYLIGHT_BACKGROUND,
  &_swigt__p_p__dwg_object_SOLID_BACKGROUND,
  &_swigt__p_p__dwg_object_SORTENTSTABLE,
  &_swigt__p_p__dwg_object_SPATIAL_FILTER,
  &_swigt__p_p__dwg_object_SPATIAL_INDEX,
  &_swigt__p_p__dwg_object_STYLE,
  &_swigt__p_p__dwg_object_STYLE_CONTROL,
  &_swigt__p_p__dwg_object_SUN,
  &_swigt__p_p__dwg_object_TABLEGEOMETRY,
  &_swigt__p_p__dwg_object_TABLESTYLE,
  &_swigt__p_p__dwg_object_TEXTOBJECTCONTEXTDATA,
  &_swigt__p_p__dwg_object_UCS,
  &_swigt__p_p__dwg_object_UCS_CONTROL,
  &_swigt__p_p__dwg_object_UNKNOWN_OBJ,
  &_swigt__p_p__dwg_object_VBA_PROJECT,
  &_swigt__p_p__dwg_object_VIEW,
  &_swigt__p_p__dwg_object_VIEW_CONTROL,
  &_swigt__p_p__dwg_object_VISUALSTYLE,
  &_swigt__p_p__dwg_object_VPORT,
  &_swigt__p_p__dwg_object_VPORT_CONTROL,
  &_swigt__p_p__dwg_object_VX_CONTROL,
  &_swigt__p_p__dwg_object_VX_TABLE_RECORD,
  &_swigt__p_p__dwg_object_WIPEOUTVARIABLES,
  &_swigt__p_p__dwg_object_XRECORD,
  &_swigt__p_p__dwg_object_entity,
  &_swigt__p_p__dwg_object_ref,
  &_swigt__p_p__dwg_section,
  &_swigt__p_p_char,
  &_swigt__p_r2007_file_header,
  &_swigt__p_rgbpalette,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
};

static swig_cast_info _swigc__p_DWG_CLASS_STABILITY[] = {  {&_swigt__p_DWG_CLASS_STABILITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_COLOR_METHOD[] = {  {&_swigt__p_DWG_COLOR_METHOD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_ENTITY_SECTIONS[] = {  {&_swigt__p_DWG_ENTITY_SECTIONS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_ERROR[] = {  {&_swigt__p_DWG_ERROR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_HDL_CODE[] = {  {&_swigt__p_DWG_HDL_CODE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_OBJECT_SUPERTYPE[] = {  {&_swigt__p_DWG_OBJECT_SUPERTYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_OBJECT_TYPE[] = {  {&_swigt__p_DWG_OBJECT_TYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_OBJECT_TYPE_R11[] = {  {&_swigt__p_DWG_OBJECT_TYPE_R11, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_SECTION_TYPE[] = {  {&_swigt__p_DWG_SECTION_TYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_SECTION_TYPE_R11[] = {  {&_swigt__p_DWG_SECTION_TYPE_R11, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_SECTION_TYPE_R13[] = {  {&_swigt__p_DWG_SECTION_TYPE_R13, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DWG_VERSION_TYPE[] = {  {&_swigt__p_DWG_VERSION_TYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dwg_Section_Info[] = {  {&_swigt__p_Dwg_Section_Info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dwg_Section_InfoHdr[] = {  {&_swigt__p_Dwg_Section_InfoHdr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RESBUF_VALUE_TYPE[] = {  {&_swigt__p_RESBUF_VALUE_TYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_3DSOLID_material[] = {  {&_swigt__p__dwg_3DSOLID_material, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_3DSOLID_silhouette[] = {  {&_swigt__p__dwg_3DSOLID_silhouette, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_3DSOLID_wire[] = {  {&_swigt__p__dwg_3DSOLID_wire, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ACSH_HistoryNode[] = {  {&_swigt__p__dwg_ACSH_HistoryNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ACSH_SubentColor[] = {  {&_swigt__p__dwg_ACSH_SubentColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ACSH_SubentMaterial[] = {  {&_swigt__p__dwg_ACSH_SubentMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ACTIONBODY[] = {  {&_swigt__p__dwg_ACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ARRAYITEMLOCATOR[] = {  {&_swigt__p__dwg_ARRAYITEMLOCATOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ASSOCACTIONBODY_action[] = {  {&_swigt__p__dwg_ASSOCACTIONBODY_action, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ASSOCACTION_Deps[] = {  {&_swigt__p__dwg_ASSOCACTION_Deps, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ASSOCARRAYITEM[] = {  {&_swigt__p__dwg_ASSOCARRAYITEM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ASSOCPARAMBASEDACTIONBODY[] = {  {&_swigt__p__dwg_ASSOCPARAMBASEDACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ASSOCSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_ASSOCSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDbMTextObjectEmbedded[] = {  {&_swigt__p__dwg_AcDbMTextObjectEmbedded, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs[] = {  {&_swigt__p__dwg_AcDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Data[] = {  {&_swigt__p__dwg_AcDs_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataBlob[] = {  {&_swigt__p__dwg_AcDs_DataBlob, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataBlob01[] = {  {&_swigt__p__dwg_AcDs_DataBlob01, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataBlobRef[] = {  {&_swigt__p__dwg_AcDs_DataBlobRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataBlobRef_Page[] = {  {&_swigt__p__dwg_AcDs_DataBlobRef_Page, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataIndex[] = {  {&_swigt__p__dwg_AcDs_DataIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_DataIndex_Entry[] = {  {&_swigt__p__dwg_AcDs_DataIndex_Entry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Data_Record[] = {  {&_swigt__p__dwg_AcDs_Data_Record, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Data_RecordHdr[] = {  {&_swigt__p__dwg_AcDs_Data_RecordHdr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Schema[] = {  {&_swigt__p__dwg_AcDs_Schema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_SchemaData[] = {  {&_swigt__p__dwg_AcDs_SchemaData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_SchemaData_UProp[] = {  {&_swigt__p__dwg_AcDs_SchemaData_UProp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_SchemaIndex[] = {  {&_swigt__p__dwg_AcDs_SchemaIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_SchemaIndex_Prop[] = {  {&_swigt__p__dwg_AcDs_SchemaIndex_Prop, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Schema_Prop[] = {  {&_swigt__p__dwg_AcDs_Schema_Prop, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Search[] = {  {&_swigt__p__dwg_AcDs_Search, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Search_Data[] = {  {&_swigt__p__dwg_AcDs_Search_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Search_IdIdx[] = {  {&_swigt__p__dwg_AcDs_Search_IdIdx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Search_IdIdxs[] = {  {&_swigt__p__dwg_AcDs_Search_IdIdxs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_Segment[] = {  {&_swigt__p__dwg_AcDs_Segment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_AcDs_SegmentIndex[] = {  {&_swigt__p__dwg_AcDs_SegmentIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKACTION_connectionpts[] = {  {&_swigt__p__dwg_BLOCKACTION_connectionpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKLOOKUPACTION_lut[] = {  {&_swigt__p__dwg_BLOCKLOOKUPACTION_lut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKPARAMETER_PropInfo[] = {  {&_swigt__p__dwg_BLOCKPARAMETER_PropInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKPARAMETER_connection[] = {  {&_swigt__p__dwg_BLOCKPARAMETER_connection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKPARAMVALUESET[] = {  {&_swigt__p__dwg_BLOCKPARAMVALUESET, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKSTRETCHACTION_codes[] = {  {&_swigt__p__dwg_BLOCKSTRETCHACTION_codes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKSTRETCHACTION_handles[] = {  {&_swigt__p__dwg_BLOCKSTRETCHACTION_handles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_BLOCKVISIBILITYPARAMETER_state[] = {  {&_swigt__p__dwg_BLOCKVISIBILITYPARAMETER_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_COMPOUNDOBJECTID[] = {  {&_swigt__p__dwg_COMPOUNDOBJECTID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_CONSTRAINTGROUPNODE[] = {  {&_swigt__p__dwg_CONSTRAINTGROUPNODE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_CONTEXTDATA_dict[] = {  {&_swigt__p__dwg_CONTEXTDATA_dict, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_CONTEXTDATA_submgr[] = {  {&_swigt__p__dwg_CONTEXTDATA_submgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_CellContentGeometry[] = {  {&_swigt__p__dwg_CellContentGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_CellStyle[] = {  {&_swigt__p__dwg_CellStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ColorRamp[] = {  {&_swigt__p__dwg_ColorRamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_ContentFormat[] = {  {&_swigt__p__dwg_ContentFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_DATALINK_customdata[] = {  {&_swigt__p__dwg_DATALINK_customdata, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_DATATABLE_column[] = {  {&_swigt__p__dwg_DATATABLE_column, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_DATATABLE_row[] = {  {&_swigt__p__dwg_DATATABLE_row, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_DIMASSOC_Ref[] = {  {&_swigt__p__dwg_DIMASSOC_Ref, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_DIMENSION_common[] = {  {&_swigt__p__dwg_DIMENSION_common, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EVAL_Edge[] = {  {&_swigt__p__dwg_EVAL_Edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EVAL_Node[] = {  {&_swigt__p__dwg_EVAL_Node, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EvalExpr[] = {  {&_swigt__p__dwg_EvalExpr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EvalExpr_value[] = {  {&_swigt__p__dwg_EvalExpr_value, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EvalVariant[] = {  {&_swigt__p__dwg_EvalVariant, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_EvalVariant_u[] = {  {&_swigt__p__dwg_EvalVariant_u, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_FIELD_ChildValue[] = {  {&_swigt__p__dwg_FIELD_ChildValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_FileDepList_Files[] = {  {&_swigt__p__dwg_FileDepList_Files, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_FormattedTableData[] = {  {&_swigt__p__dwg_FormattedTableData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_FormattedTableMerged[] = {  {&_swigt__p__dwg_FormattedTableMerged, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_GEODATA_meshface[] = {  {&_swigt__p__dwg_GEODATA_meshface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_GEODATA_meshpt[] = {  {&_swigt__p__dwg_GEODATA_meshpt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_GridFormat[] = {  {&_swigt__p__dwg_GridFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_Color[] = {  {&_swigt__p__dwg_HATCH_Color, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_ControlPoint[] = {  {&_swigt__p__dwg_HATCH_ControlPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_DefLine[] = {  {&_swigt__p__dwg_HATCH_DefLine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_Path[] = {  {&_swigt__p__dwg_HATCH_Path, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_PathSeg[] = {  {&_swigt__p__dwg_HATCH_PathSeg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_HATCH_PolylinePath[] = {  {&_swigt__p__dwg_HATCH_PolylinePath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LAYER_entry[] = {  {&_swigt__p__dwg_LAYER_entry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LEADER_ArrowHead[] = {  {&_swigt__p__dwg_LEADER_ArrowHead, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LEADER_BlockLabel[] = {  {&_swigt__p__dwg_LEADER_BlockLabel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LEADER_Break[] = {  {&_swigt__p__dwg_LEADER_Break, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LEADER_Line[] = {  {&_swigt__p__dwg_LEADER_Line, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LEADER_Node[] = {  {&_swigt__p__dwg_LEADER_Node, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LIGHTLIST_light[] = {  {&_swigt__p__dwg_LIGHTLIST_light, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LTYPE_dash[] = {  {&_swigt__p__dwg_LTYPE_dash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LWPOLYLINE_width[] = {  {&_swigt__p__dwg_LWPOLYLINE_width, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LinkedData[] = {  {&_swigt__p__dwg_LinkedData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_LinkedTableData[] = {  {&_swigt__p__dwg_LinkedTableData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MATERIAL_color[] = {  {&_swigt__p__dwg_MATERIAL_color, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MATERIAL_gentexture[] = {  {&_swigt__p__dwg_MATERIAL_gentexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MATERIAL_mapper[] = {  {&_swigt__p__dwg_MATERIAL_mapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MESH_edge[] = {  {&_swigt__p__dwg_MESH_edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLEADER_AnnotContext[] = {  {&_swigt__p__dwg_MLEADER_AnnotContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLEADER_Content[] = {  {&_swigt__p__dwg_MLEADER_Content, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLEADER_Content_Block[] = {  {&_swigt__p__dwg_MLEADER_Content_Block, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLEADER_Content_MText[] = {  {&_swigt__p__dwg_MLEADER_Content_MText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLINESTYLE_line[] = {  {&_swigt__p__dwg_MLINESTYLE_line, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLINESTYLE_line_lt[] = {  {&_swigt__p__dwg_MLINESTYLE_line_lt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLINE_line[] = {  {&_swigt__p__dwg_MLINE_line, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_MLINE_vertex[] = {  {&_swigt__p__dwg_MLINE_vertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_OCD_Dimension[] = {  {&_swigt__p__dwg_OCD_Dimension, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_PARTIAL_VIEWING_INDEX_Entry[] = {  {&_swigt__p__dwg_PARTIAL_VIEWING_INDEX_Entry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_POINTCLOUDCOLORMAP_Ramp[] = {  {&_swigt__p__dwg_POINTCLOUDCOLORMAP_Ramp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_POINTCLOUDEX_Croppings[] = {  {&_swigt__p__dwg_POINTCLOUDEX_Croppings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_POINTCLOUD_Clippings[] = {  {&_swigt__p__dwg_POINTCLOUD_Clippings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_POINTCLOUD_IntensityStyle[] = {  {&_swigt__p__dwg_POINTCLOUD_IntensityStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_PROXY_LWPOLYLINE[] = {  {&_swigt__p__dwg_PROXY_LWPOLYLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_R2004_Header[] = {  {&_swigt__p__dwg_R2004_Header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_SECTION_geometrysettings[] = {  {&_swigt__p__dwg_SECTION_geometrysettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_SECTION_typesettings[] = {  {&_swigt__p__dwg_SECTION_typesettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_SPLINE_control_point[] = {  {&_swigt__p__dwg_SPLINE_control_point, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_SUNSTUDY_Dates[] = {  {&_swigt__p__dwg_SUNSTUDY_Dates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_SummaryInfo_Property[] = {  {&_swigt__p__dwg_SummaryInfo_Property, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLEGEOMETRY_Cell[] = {  {&_swigt__p__dwg_TABLEGEOMETRY_Cell, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLESTYLE_CellStyle[] = {  {&_swigt__p__dwg_TABLESTYLE_CellStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLESTYLE_border[] = {  {&_swigt__p__dwg_TABLESTYLE_border, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLESTYLE_rowstyles[] = {  {&_swigt__p__dwg_TABLESTYLE_rowstyles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_AttrDef[] = {  {&_swigt__p__dwg_TABLE_AttrDef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_BreakHeight[] = {  {&_swigt__p__dwg_TABLE_BreakHeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_BreakRow[] = {  {&_swigt__p__dwg_TABLE_BreakRow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_Cell[] = {  {&_swigt__p__dwg_TABLE_Cell, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_CustomDataItem[] = {  {&_swigt__p__dwg_TABLE_CustomDataItem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TABLE_value[] = {  {&_swigt__p__dwg_TABLE_value, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TableCell[] = {  {&_swigt__p__dwg_TableCell, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TableCellContent[] = {  {&_swigt__p__dwg_TableCellContent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TableCellContent_Attr[] = {  {&_swigt__p__dwg_TableCellContent_Attr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TableDataColumn[] = {  {&_swigt__p__dwg_TableDataColumn, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_TableRow[] = {  {&_swigt__p__dwg_TableRow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_UCS_orthopts[] = {  {&_swigt__p__dwg_UCS_orthopts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_VALUEPARAM[] = {  {&_swigt__p__dwg_VALUEPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_VALUEPARAM_vars[] = {  {&_swigt__p__dwg_VALUEPARAM_vars, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_abstractentity_UNDERLAY[] = {  {&_swigt__p__dwg_abstractentity_UNDERLAY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_abstractobject_ASSOCARRAYPARAMETERS[] = {  {&_swigt__p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_abstractobject_UNDERLAYDEFINITION[] = {  {&_swigt__p__dwg_abstractobject_UNDERLAYDEFINITION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_appinfo[] = {  {&_swigt__p__dwg_appinfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_appinfohistory[] = {  {&_swigt__p__dwg_appinfohistory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_auxheader[] = {  {&_swigt__p__dwg_auxheader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_binary_chunk[] = {  {&_swigt__p__dwg_binary_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_binary_chunk_u[] = {  {&_swigt__p__dwg_binary_chunk_u, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_bitcode_2bd[] = {  {&_swigt__p__dwg_bitcode_2bd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_bitcode_2rd[] = {  {&_swigt__p__dwg_bitcode_2rd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_bitcode_3bd[] = {  {&_swigt__p__dwg_bitcode_3bd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_bitcode_3rd[] = {  {&_swigt__p__dwg_bitcode_3rd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_chain[] = {  {&_swigt__p__dwg_chain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_class[] = {  {&_swigt__p__dwg_class, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_color[] = {  {&_swigt__p__dwg_color, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_3DFACE[] = {  {&_swigt__p__dwg_entity_3DFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_3DLINE[] = {  {&_swigt__p__dwg_entity_3DLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_3DSOLID[] = {  {&_swigt__p__dwg_entity_3DSOLID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ALIGNMENTPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_ALIGNMENTPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ARC[] = {  {&_swigt__p__dwg_entity_ARC, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ARCALIGNEDTEXT[] = {  {&_swigt__p__dwg_entity_ARCALIGNEDTEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ARC_DIMENSION[] = {  {&_swigt__p__dwg_entity_ARC_DIMENSION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ATTDEF[] = {  {&_swigt__p__dwg_entity_ATTDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ATTRIB[] = {  {&_swigt__p__dwg_entity_ATTRIB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_BASEPOINTPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_BASEPOINTPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_BLOCK[] = {  {&_swigt__p__dwg_entity_BLOCK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_CAMERA[] = {  {&_swigt__p__dwg_entity_CAMERA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_CIRCLE[] = {  {&_swigt__p__dwg_entity_CIRCLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_ALIGNED[] = {  {&_swigt__p__dwg_entity_DIMENSION_ALIGNED, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_ANG2LN[] = {  {&_swigt__p__dwg_entity_DIMENSION_ANG2LN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_ANG3PT[] = {  {&_swigt__p__dwg_entity_DIMENSION_ANG3PT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_DIAMETER[] = {  {&_swigt__p__dwg_entity_DIMENSION_DIAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_LINEAR[] = {  {&_swigt__p__dwg_entity_DIMENSION_LINEAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_ORDINATE[] = {  {&_swigt__p__dwg_entity_DIMENSION_ORDINATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_DIMENSION_RADIUS[] = {  {&_swigt__p__dwg_entity_DIMENSION_RADIUS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ELLIPSE[] = {  {&_swigt__p__dwg_entity_ELLIPSE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ENDBLK[] = {  {&_swigt__p__dwg_entity_ENDBLK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ENDREP[] = {  {&_swigt__p__dwg_entity_ENDREP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_EXTRUDEDSURFACE[] = {  {&_swigt__p__dwg_entity_EXTRUDEDSURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_FLIPGRIPENTITY[] = {  {&_swigt__p__dwg_entity_FLIPGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_FLIPPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_FLIPPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_GEOPOSITIONMARKER[] = {  {&_swigt__p__dwg_entity_GEOPOSITIONMARKER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_HATCH[] = {  {&_swigt__p__dwg_entity_HATCH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_HELIX[] = {  {&_swigt__p__dwg_entity_HELIX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_IMAGE[] = {  {&_swigt__p__dwg_entity_IMAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_INSERT[] = {  {&_swigt__p__dwg_entity_INSERT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_JUMP[] = {  {&_swigt__p__dwg_entity_JUMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LARGE_RADIAL_DIMENSION[] = {  {&_swigt__p__dwg_entity_LARGE_RADIAL_DIMENSION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LAYOUTPRINTCONFIG[] = {  {&_swigt__p__dwg_entity_LAYOUTPRINTCONFIG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LEADER[] = {  {&_swigt__p__dwg_entity_LEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LIGHT[] = {  {&_swigt__p__dwg_entity_LIGHT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LINE[] = {  {&_swigt__p__dwg_entity_LINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LINEARGRIPENTITY[] = {  {&_swigt__p__dwg_entity_LINEARGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LINEARPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_LINEARPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LOAD[] = {  {&_swigt__p__dwg_entity_LOAD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LOFTEDSURFACE[] = {  {&_swigt__p__dwg_entity_LOFTEDSURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_LWPOLYLINE[] = {  {&_swigt__p__dwg_entity_LWPOLYLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MESH[] = {  {&_swigt__p__dwg_entity_MESH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MINSERT[] = {  {&_swigt__p__dwg_entity_MINSERT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MLINE[] = {  {&_swigt__p__dwg_entity_MLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MPOLYGON[] = {  {&_swigt__p__dwg_entity_MPOLYGON, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MTEXT[] = {  {&_swigt__p__dwg_entity_MTEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_MULTILEADER[] = {  {&_swigt__p__dwg_entity_MULTILEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_NAVISWORKSMODEL[] = {  {&_swigt__p__dwg_entity_NAVISWORKSMODEL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_NURBSURFACE[] = {  {&_swigt__p__dwg_entity_NURBSURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_OLE2FRAME[] = {  {&_swigt__p__dwg_entity_OLE2FRAME, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_OLEFRAME[] = {  {&_swigt__p__dwg_entity_OLEFRAME, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_PLANESURFACE[] = {  {&_swigt__p__dwg_entity_PLANESURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POINT[] = {  {&_swigt__p__dwg_entity_POINT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POINTCLOUD[] = {  {&_swigt__p__dwg_entity_POINTCLOUD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POINTCLOUDEX[] = {  {&_swigt__p__dwg_entity_POINTCLOUDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POINTPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_POINTPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POLARGRIPENTITY[] = {  {&_swigt__p__dwg_entity_POLARGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POLYLINE_2D[] = {  {&_swigt__p__dwg_entity_POLYLINE_2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POLYLINE_3D[] = {  {&_swigt__p__dwg_entity_POLYLINE_3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POLYLINE_MESH[] = {  {&_swigt__p__dwg_entity_POLYLINE_MESH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_POLYLINE_PFACE[] = {  {&_swigt__p__dwg_entity_POLYLINE_PFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_PROXY_ENTITY[] = {  {&_swigt__p__dwg_entity_PROXY_ENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_RAY[] = {  {&_swigt__p__dwg_entity_RAY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_REPEAT[] = {  {&_swigt__p__dwg_entity_REPEAT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_REVOLVEDSURFACE[] = {  {&_swigt__p__dwg_entity_REVOLVEDSURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ROTATIONGRIPENTITY[] = {  {&_swigt__p__dwg_entity_ROTATIONGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_ROTATIONPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_ROTATIONPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_RTEXT[] = {  {&_swigt__p__dwg_entity_RTEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SECTIONOBJECT[] = {  {&_swigt__p__dwg_entity_SECTIONOBJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SEQEND[] = {  {&_swigt__p__dwg_entity_SEQEND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SHAPE[] = {  {&_swigt__p__dwg_entity_SHAPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SOLID[] = {  {&_swigt__p__dwg_entity_SOLID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SPLINE[] = {  {&_swigt__p__dwg_entity_SPLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_SWEPTSURFACE[] = {  {&_swigt__p__dwg_entity_SWEPTSURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_TABLE[] = {  {&_swigt__p__dwg_entity_TABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_TEXT[] = {  {&_swigt__p__dwg_entity_TEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_TOLERANCE[] = {  {&_swigt__p__dwg_entity_TOLERANCE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_TRACE[] = {  {&_swigt__p__dwg_entity_TRACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_UNKNOWN_ENT[] = {  {&_swigt__p__dwg_entity_UNKNOWN_ENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VERTEX_2D[] = {  {&_swigt__p__dwg_entity_VERTEX_2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VERTEX_3D[] = {  {&_swigt__p__dwg_entity_VERTEX_3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VERTEX_PFACE_FACE[] = {  {&_swigt__p__dwg_entity_VERTEX_PFACE_FACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VIEWPORT[] = {  {&_swigt__p__dwg_entity_VIEWPORT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VISIBILITYGRIPENTITY[] = {  {&_swigt__p__dwg_entity_VISIBILITYGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_VISIBILITYPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_VISIBILITYPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_WIPEOUT[] = {  {&_swigt__p__dwg_entity_WIPEOUT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_XYGRIPENTITY[] = {  {&_swigt__p__dwg_entity_XYGRIPENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_XYPARAMETERENTITY[] = {  {&_swigt__p__dwg_entity_XYPARAMETERENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_eed[] = {  {&_swigt__p__dwg_entity_eed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_entity_eed_data[] = {  {&_swigt__p__dwg_entity_eed_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_filedeplist[] = {  {&_swigt__p__dwg_filedeplist, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_handle[] = {  {&_swigt__p__dwg_handle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_header[] = {  {&_swigt__p__dwg_header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_header_variables[] = {  {&_swigt__p__dwg_header_variables, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object[] = {  {&_swigt__p__dwg_object, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACMECOMMANDHISTORY[] = {  {&_swigt__p__dwg_object_ACMECOMMANDHISTORY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACMESCOPE[] = {  {&_swigt__p__dwg_object_ACMESCOPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACMESTATEMGR[] = {  {&_swigt__p__dwg_object_ACMESTATEMGR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_BOOLEAN_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_BOOLEAN_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_BOX_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_BOX_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_BREP_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_BREP_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_CHAMFER_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_CHAMFER_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_CONE_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_CONE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_CYLINDER_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_CYLINDER_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_EXTRUSION_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_EXTRUSION_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_FILLET_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_FILLET_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_HISTORY_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_HISTORY_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_LOFT_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_LOFT_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_PYRAMID_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_PYRAMID_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_REVOLVE_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_REVOLVE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_SPHERE_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_SPHERE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_SWEEP_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_SWEEP_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_TORUS_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_TORUS_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ACSH_WEDGE_CLASS[] = {  {&_swigt__p__dwg_object_ACSH_WEDGE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ALDIMOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ANGDIMOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_ANGDIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_APPID[] = {  {&_swigt__p__dwg_object_APPID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_APPID_CONTROL[] = {  {&_swigt__p__dwg_object_APPID_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOC2DCONSTRAINTGROUP[] = {  {&_swigt__p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCACTION[] = {  {&_swigt__p__dwg_object_ASSOCACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCALIGNEDDIMACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCALIGNEDDIMACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCARRAYACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCARRAYACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCARRAYMODIFYACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCARRAYMODIFYACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCASMBODYACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCASMBODYACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCBLENDSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCCOMPOUNDACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCDEPENDENCY[] = {  {&_swigt__p__dwg_object_ASSOCDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCDIMDEPENDENCYBODY[] = {  {&_swigt__p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCEDGEACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCEDGEACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCEDGECHAMFERACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCEDGECHAMFERACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCEDGEFILLETACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCEDGEFILLETACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCFACEACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCFACEACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCFILLETSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCGEOMDEPENDENCY[] = {  {&_swigt__p__dwg_object_ASSOCGEOMDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCMLEADERACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCMLEADERACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCNETWORK[] = {  {&_swigt__p__dwg_object_ASSOCNETWORK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCOBJECTACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCOBJECTACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCORDINATEDIMACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCORDINATEDIMACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCPATCHSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCPATHACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCPATHACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCPERSSUBENTMANAGER[] = {  {&_swigt__p__dwg_object_ASSOCPERSSUBENTMANAGER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCPLANESURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCPOINTREFACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCROTATEDDIMACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCROTATEDDIMACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCTRIMSURFACEACTIONBODY[] = {  {&_swigt__p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCVALUEDEPENDENCY[] = {  {&_swigt__p__dwg_object_ASSOCVALUEDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCVARIABLE[] = {  {&_swigt__p__dwg_object_ASSOCVARIABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ASSOCVERTEXACTIONPARAM[] = {  {&_swigt__p__dwg_object_ASSOCVERTEXACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLKREFOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKALIGNMENTGRIP[] = {  {&_swigt__p__dwg_object_BLOCKALIGNMENTGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKALIGNMENTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKALIGNMENTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKARRAYACTION[] = {  {&_swigt__p__dwg_object_BLOCKARRAYACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKBASEPOINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKBASEPOINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKFLIPACTION[] = {  {&_swigt__p__dwg_object_BLOCKFLIPACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKFLIPGRIP[] = {  {&_swigt__p__dwg_object_BLOCKFLIPGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKFLIPPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKFLIPPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT[] = {  {&_swigt__p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLINEARGRIP[] = {  {&_swigt__p__dwg_object_BLOCKLINEARGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLINEARPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKLINEARPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLOOKUPACTION[] = {  {&_swigt__p__dwg_object_BLOCKLOOKUPACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLOOKUPGRIP[] = {  {&_swigt__p__dwg_object_BLOCKLOOKUPGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKLOOKUPPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKLOOKUPPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKMOVEACTION[] = {  {&_swigt__p__dwg_object_BLOCKMOVEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPARAMDEPENDENCYBODY[] = {  {&_swigt__p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPOINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKPOINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPOLARGRIP[] = {  {&_swigt__p__dwg_object_BLOCKPOLARGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPOLARPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKPOLARPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPOLARSTRETCHACTION[] = {  {&_swigt__p__dwg_object_BLOCKPOLARSTRETCHACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPROPERTIESTABLE[] = {  {&_swigt__p__dwg_object_BLOCKPROPERTIESTABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKPROPERTIESTABLEGRIP[] = {  {&_swigt__p__dwg_object_BLOCKPROPERTIESTABLEGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKREPRESENTATION[] = {  {&_swigt__p__dwg_object_BLOCKREPRESENTATION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKROTATEACTION[] = {  {&_swigt__p__dwg_object_BLOCKROTATEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKROTATIONGRIP[] = {  {&_swigt__p__dwg_object_BLOCKROTATIONGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKROTATIONPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKROTATIONPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKSCALEACTION[] = {  {&_swigt__p__dwg_object_BLOCKSCALEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKSTRETCHACTION[] = {  {&_swigt__p__dwg_object_BLOCKSTRETCHACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKUSERPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKUSERPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKVISIBILITYGRIP[] = {  {&_swigt__p__dwg_object_BLOCKVISIBILITYGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKVISIBILITYPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKVISIBILITYPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKXYGRIP[] = {  {&_swigt__p__dwg_object_BLOCKXYGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCKXYPARAMETER[] = {  {&_swigt__p__dwg_object_BLOCKXYPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCK_CONTROL[] = {  {&_swigt__p__dwg_object_BLOCK_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BLOCK_HEADER[] = {  {&_swigt__p__dwg_object_BLOCK_HEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BREAKDATA[] = {  {&_swigt__p__dwg_object_BREAKDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_BREAKPOINTREF[] = {  {&_swigt__p__dwg_object_BREAKPOINTREF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_CELLSTYLEMAP[] = {  {&_swigt__p__dwg_object_CELLSTYLEMAP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_CONTEXTDATAMANAGER[] = {  {&_swigt__p__dwg_object_CONTEXTDATAMANAGER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_CSACDOCUMENTOPTIONS[] = {  {&_swigt__p__dwg_object_CSACDOCUMENTOPTIONS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_CURVEPATH[] = {  {&_swigt__p__dwg_object_CURVEPATH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DATALINK[] = {  {&_swigt__p__dwg_object_DATALINK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DATATABLE[] = {  {&_swigt__p__dwg_object_DATATABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DBCOLOR[] = {  {&_swigt__p__dwg_object_DBCOLOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DETAILVIEWSTYLE[] = {  {&_swigt__p__dwg_object_DETAILVIEWSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DICTIONARY[] = {  {&_swigt__p__dwg_object_DICTIONARY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DICTIONARYVAR[] = {  {&_swigt__p__dwg_object_DICTIONARYVAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DICTIONARYWDFLT[] = {  {&_swigt__p__dwg_object_DICTIONARYWDFLT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DIMASSOC[] = {  {&_swigt__p__dwg_object_DIMASSOC, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DIMSTYLE[] = {  {&_swigt__p__dwg_object_DIMSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DIMSTYLE_CONTROL[] = {  {&_swigt__p__dwg_object_DIMSTYLE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DMDIMOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_DMDIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DUMMY[] = {  {&_swigt__p__dwg_object_DUMMY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DYNAMICBLOCKPROXYNODE[] = {  {&_swigt__p__dwg_object_DYNAMICBLOCKPROXYNODE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_DYNAMICBLOCKPURGEPREVENTER[] = {  {&_swigt__p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_EVALUATION_GRAPH[] = {  {&_swigt__p__dwg_object_EVALUATION_GRAPH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_FCFOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_FCFOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_FIELD[] = {  {&_swigt__p__dwg_object_FIELD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_FIELDLIST[] = {  {&_swigt__p__dwg_object_FIELDLIST, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_GEODATA[] = {  {&_swigt__p__dwg_object_GEODATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_GEOMAPIMAGE[] = {  {&_swigt__p__dwg_object_GEOMAPIMAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_GRADIENT_BACKGROUND[] = {  {&_swigt__p__dwg_object_GRADIENT_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_GROUND_PLANE_BACKGROUND[] = {  {&_swigt__p__dwg_object_GROUND_PLANE_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_GROUP[] = {  {&_swigt__p__dwg_object_GROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_IBL_BACKGROUND[] = {  {&_swigt__p__dwg_object_IBL_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_IDBUFFER[] = {  {&_swigt__p__dwg_object_IDBUFFER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_IMAGEDEF[] = {  {&_swigt__p__dwg_object_IMAGEDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_IMAGEDEF_REACTOR[] = {  {&_swigt__p__dwg_object_IMAGEDEF_REACTOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_IMAGE_BACKGROUND[] = {  {&_swigt__p__dwg_object_IMAGE_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_INDEX[] = {  {&_swigt__p__dwg_object_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LAYER[] = {  {&_swigt__p__dwg_object_LAYER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LAYERFILTER[] = {  {&_swigt__p__dwg_object_LAYERFILTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LAYER_CONTROL[] = {  {&_swigt__p__dwg_object_LAYER_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LAYER_INDEX[] = {  {&_swigt__p__dwg_object_LAYER_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LAYOUT[] = {  {&_swigt__p__dwg_object_LAYOUT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LEADEROBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_LEADEROBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LIGHTLIST[] = {  {&_swigt__p__dwg_object_LIGHTLIST, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LONG_TRANSACTION[] = {  {&_swigt__p__dwg_object_LONG_TRANSACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LTYPE[] = {  {&_swigt__p__dwg_object_LTYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_LTYPE_CONTROL[] = {  {&_swigt__p__dwg_object_LTYPE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MATERIAL[] = {  {&_swigt__p__dwg_object_MATERIAL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MENTALRAYRENDERSETTINGS[] = {  {&_swigt__p__dwg_object_MENTALRAYRENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MLEADEROBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_MLEADEROBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MLEADERSTYLE[] = {  {&_swigt__p__dwg_object_MLEADERSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MLINESTYLE[] = {  {&_swigt__p__dwg_object_MLINESTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MOTIONPATH[] = {  {&_swigt__p__dwg_object_MOTIONPATH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_MTEXTOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_NAVISWORKSMODELDEF[] = {  {&_swigt__p__dwg_object_NAVISWORKSMODELDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_OBJECT_PTR[] = {  {&_swigt__p__dwg_object_OBJECT_PTR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ORDDIMOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_ORDDIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_PARTIAL_VIEWING_INDEX[] = {  {&_swigt__p__dwg_object_PARTIAL_VIEWING_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_PERSUBENTMGR[] = {  {&_swigt__p__dwg_object_PERSUBENTMGR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_PLACEHOLDER[] = {  {&_swigt__p__dwg_object_PLACEHOLDER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_PLOTSETTINGS[] = {  {&_swigt__p__dwg_object_PLOTSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTCLOUDCOLORMAP[] = {  {&_swigt__p__dwg_object_POINTCLOUDCOLORMAP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTCLOUDDEF[] = {  {&_swigt__p__dwg_object_POINTCLOUDDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTCLOUDDEFEX[] = {  {&_swigt__p__dwg_object_POINTCLOUDDEFEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTCLOUDDEF_REACTOR[] = {  {&_swigt__p__dwg_object_POINTCLOUDDEF_REACTOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTCLOUDDEF_REACTOR_EX[] = {  {&_swigt__p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_POINTPATH[] = {  {&_swigt__p__dwg_object_POINTPATH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_PROXY_OBJECT[] = {  {&_swigt__p__dwg_object_PROXY_OBJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RADIMLGOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_RADIMLGOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RADIMOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_RADIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RAPIDRTRENDERSETTINGS[] = {  {&_swigt__p__dwg_object_RAPIDRTRENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RASTERVARIABLES[] = {  {&_swigt__p__dwg_object_RASTERVARIABLES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RENDERENTRY[] = {  {&_swigt__p__dwg_object_RENDERENTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RENDERENVIRONMENT[] = {  {&_swigt__p__dwg_object_RENDERENVIRONMENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RENDERGLOBAL[] = {  {&_swigt__p__dwg_object_RENDERGLOBAL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_RENDERSETTINGS[] = {  {&_swigt__p__dwg_object_RENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SCALE[] = {  {&_swigt__p__dwg_object_SCALE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SECTIONVIEWSTYLE[] = {  {&_swigt__p__dwg_object_SECTIONVIEWSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SECTION_MANAGER[] = {  {&_swigt__p__dwg_object_SECTION_MANAGER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SECTION_SETTINGS[] = {  {&_swigt__p__dwg_object_SECTION_SETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SKYLIGHT_BACKGROUND[] = {  {&_swigt__p__dwg_object_SKYLIGHT_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SOLID_BACKGROUND[] = {  {&_swigt__p__dwg_object_SOLID_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SORTENTSTABLE[] = {  {&_swigt__p__dwg_object_SORTENTSTABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SPATIAL_FILTER[] = {  {&_swigt__p__dwg_object_SPATIAL_FILTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SPATIAL_INDEX[] = {  {&_swigt__p__dwg_object_SPATIAL_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_STYLE[] = {  {&_swigt__p__dwg_object_STYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_STYLE_CONTROL[] = {  {&_swigt__p__dwg_object_STYLE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SUN[] = {  {&_swigt__p__dwg_object_SUN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_SUNSTUDY[] = {  {&_swigt__p__dwg_object_SUNSTUDY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_TABLECONTENT[] = {  {&_swigt__p__dwg_object_TABLECONTENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_TABLEGEOMETRY[] = {  {&_swigt__p__dwg_object_TABLEGEOMETRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_TABLESTYLE[] = {  {&_swigt__p__dwg_object_TABLESTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_TEXTOBJECTCONTEXTDATA[] = {  {&_swigt__p__dwg_object_TEXTOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_TVDEVICEPROPERTIES[] = {  {&_swigt__p__dwg_object_TVDEVICEPROPERTIES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_UCS[] = {  {&_swigt__p__dwg_object_UCS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_UCS_CONTROL[] = {  {&_swigt__p__dwg_object_UCS_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_UNKNOWN_OBJ[] = {  {&_swigt__p__dwg_object_UNKNOWN_OBJ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VBA_PROJECT[] = {  {&_swigt__p__dwg_object_VBA_PROJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VIEW[] = {  {&_swigt__p__dwg_object_VIEW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VIEW_CONTROL[] = {  {&_swigt__p__dwg_object_VIEW_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VISUALSTYLE[] = {  {&_swigt__p__dwg_object_VISUALSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VPORT[] = {  {&_swigt__p__dwg_object_VPORT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VPORT_CONTROL[] = {  {&_swigt__p__dwg_object_VPORT_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VX_CONTROL[] = {  {&_swigt__p__dwg_object_VX_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_VX_TABLE_RECORD[] = {  {&_swigt__p__dwg_object_VX_TABLE_RECORD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_WIPEOUTVARIABLES[] = {  {&_swigt__p__dwg_object_WIPEOUTVARIABLES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_XRECORD[] = {  {&_swigt__p__dwg_object_XRECORD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_entity[] = {  {&_swigt__p__dwg_object_entity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_entity_tio[] = {  {&_swigt__p__dwg_object_entity_tio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_object[] = {  {&_swigt__p__dwg_object_object, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_object_tio[] = {  {&_swigt__p__dwg_object_object_tio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_ref[] = {  {&_swigt__p__dwg_object_ref, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_object_tio[] = {  {&_swigt__p__dwg_object_tio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_objfreespace[] = {  {&_swigt__p__dwg_objfreespace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_resbuf[] = {  {&_swigt__p__dwg_resbuf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_resbuf_value[] = {  {&_swigt__p__dwg_resbuf_value, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_revhistory[] = {  {&_swigt__p__dwg_revhistory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_secondheader[] = {  {&_swigt__p__dwg_secondheader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_secondheader_handles[] = {  {&_swigt__p__dwg_secondheader_handles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_secondheader_sections[] = {  {&_swigt__p__dwg_secondheader_sections, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_section[] = {  {&_swigt__p__dwg_section, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_security[] = {  {&_swigt__p__dwg_security, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_struct[] = {  {&_swigt__p__dwg_struct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_struct_fhdr[] = {  {&_swigt__p__dwg_struct_fhdr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_summaryinfo[] = {  {&_swigt__p__dwg_summaryinfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_template[] = {  {&_swigt__p__dwg_template, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_time_bll[] = {  {&_swigt__p__dwg_time_bll, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__dwg_vbaproject[] = {  {&_swigt__p__dwg_vbaproject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__inthash[] = {  {&_swigt__p__inthash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_entity_DIMENSION_common[] = {  {&_swigt__p_dwg_entity_DIMENSION_common, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_field_name_type_offset[] = {  {&_swigt__p_dwg_field_name_type_offset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_obj_ent[] = {  {&_swigt__p_dwg_obj_ent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_obj_generic[] = {  {&_swigt__p_dwg_obj_generic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_obj_layer[] = {  {&_swigt__p_dwg_obj_layer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_obj_obj[] = {  {&_swigt__p_dwg_obj_obj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_object[] = {  {&_swigt__p_dwg_object, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dwg_versions[] = {  {&_swigt__p_dwg_versions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t[] = {  {&_swigt__p_eed_data_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_0[] = {  {&_swigt__p_eed_data_t_eed_0, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_0_r2007[] = {  {&_swigt__p_eed_data_t_eed_0_r2007, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_1[] = {  {&_swigt__p_eed_data_t_eed_1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_10[] = {  {&_swigt__p_eed_data_t_eed_10, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_2[] = {  {&_swigt__p_eed_data_t_eed_2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_3[] = {  {&_swigt__p_eed_data_t_eed_3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_4[] = {  {&_swigt__p_eed_data_t_eed_4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_40[] = {  {&_swigt__p_eed_data_t_eed_40, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_5[] = {  {&_swigt__p_eed_data_t_eed_5, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_70[] = {  {&_swigt__p_eed_data_t_eed_70, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_eed_data_t_eed_71[] = {  {&_swigt__p_eed_data_t_eed_71, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_abstractentity_UNDERLAY[] = {  {&_swigt__p_p__dwg_abstractentity_UNDERLAY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS[] = {  {&_swigt__p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_abstractobject_UNDERLAYDEFINITION[] = {  {&_swigt__p_p__dwg_abstractobject_UNDERLAYDEFINITION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_3DFACE[] = {  {&_swigt__p_p__dwg_entity_3DFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_3DLINE[] = {  {&_swigt__p_p__dwg_entity_3DLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_3DSOLID[] = {  {&_swigt__p_p__dwg_entity_3DSOLID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ARC[] = {  {&_swigt__p_p__dwg_entity_ARC, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ARC_DIMENSION[] = {  {&_swigt__p_p__dwg_entity_ARC_DIMENSION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ATTDEF[] = {  {&_swigt__p_p__dwg_entity_ATTDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ATTRIB[] = {  {&_swigt__p_p__dwg_entity_ATTRIB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_BLOCK[] = {  {&_swigt__p_p__dwg_entity_BLOCK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_CAMERA[] = {  {&_swigt__p_p__dwg_entity_CAMERA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_CIRCLE[] = {  {&_swigt__p_p__dwg_entity_CIRCLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_ALIGNED[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_ALIGNED, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_ANG2LN[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_ANG2LN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_ANG3PT[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_ANG3PT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_DIAMETER[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_DIAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_LINEAR[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_LINEAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_ORDINATE[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_ORDINATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_DIMENSION_RADIUS[] = {  {&_swigt__p_p__dwg_entity_DIMENSION_RADIUS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ELLIPSE[] = {  {&_swigt__p_p__dwg_entity_ELLIPSE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ENDBLK[] = {  {&_swigt__p_p__dwg_entity_ENDBLK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_ENDREP[] = {  {&_swigt__p_p__dwg_entity_ENDREP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_HATCH[] = {  {&_swigt__p_p__dwg_entity_HATCH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_HELIX[] = {  {&_swigt__p_p__dwg_entity_HELIX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_IMAGE[] = {  {&_swigt__p_p__dwg_entity_IMAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_INSERT[] = {  {&_swigt__p_p__dwg_entity_INSERT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_JUMP[] = {  {&_swigt__p_p__dwg_entity_JUMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LARGE_RADIAL_DIMENSION[] = {  {&_swigt__p_p__dwg_entity_LARGE_RADIAL_DIMENSION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LAYOUTPRINTCONFIG[] = {  {&_swigt__p_p__dwg_entity_LAYOUTPRINTCONFIG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LEADER[] = {  {&_swigt__p_p__dwg_entity_LEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LIGHT[] = {  {&_swigt__p_p__dwg_entity_LIGHT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LINE[] = {  {&_swigt__p_p__dwg_entity_LINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LOAD[] = {  {&_swigt__p_p__dwg_entity_LOAD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_LWPOLYLINE[] = {  {&_swigt__p_p__dwg_entity_LWPOLYLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_MESH[] = {  {&_swigt__p_p__dwg_entity_MESH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_MINSERT[] = {  {&_swigt__p_p__dwg_entity_MINSERT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_MLINE[] = {  {&_swigt__p_p__dwg_entity_MLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_MTEXT[] = {  {&_swigt__p_p__dwg_entity_MTEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_MULTILEADER[] = {  {&_swigt__p_p__dwg_entity_MULTILEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_OLE2FRAME[] = {  {&_swigt__p_p__dwg_entity_OLE2FRAME, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_OLEFRAME[] = {  {&_swigt__p_p__dwg_entity_OLEFRAME, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_PLANESURFACE[] = {  {&_swigt__p_p__dwg_entity_PLANESURFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POINT[] = {  {&_swigt__p_p__dwg_entity_POINT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POINTCLOUD[] = {  {&_swigt__p_p__dwg_entity_POINTCLOUD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POINTCLOUDEX[] = {  {&_swigt__p_p__dwg_entity_POINTCLOUDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POLYLINE_2D[] = {  {&_swigt__p_p__dwg_entity_POLYLINE_2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POLYLINE_3D[] = {  {&_swigt__p_p__dwg_entity_POLYLINE_3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POLYLINE_MESH[] = {  {&_swigt__p_p__dwg_entity_POLYLINE_MESH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_POLYLINE_PFACE[] = {  {&_swigt__p_p__dwg_entity_POLYLINE_PFACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_PROXY_ENTITY[] = {  {&_swigt__p_p__dwg_entity_PROXY_ENTITY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_RAY[] = {  {&_swigt__p_p__dwg_entity_RAY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_REPEAT[] = {  {&_swigt__p_p__dwg_entity_REPEAT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_SECTIONOBJECT[] = {  {&_swigt__p_p__dwg_entity_SECTIONOBJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_SEQEND[] = {  {&_swigt__p_p__dwg_entity_SEQEND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_SHAPE[] = {  {&_swigt__p_p__dwg_entity_SHAPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_SOLID[] = {  {&_swigt__p_p__dwg_entity_SOLID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_SPLINE[] = {  {&_swigt__p_p__dwg_entity_SPLINE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_TEXT[] = {  {&_swigt__p_p__dwg_entity_TEXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_TOLERANCE[] = {  {&_swigt__p_p__dwg_entity_TOLERANCE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_TRACE[] = {  {&_swigt__p_p__dwg_entity_TRACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_UNKNOWN_ENT[] = {  {&_swigt__p_p__dwg_entity_UNKNOWN_ENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_VERTEX_2D[] = {  {&_swigt__p_p__dwg_entity_VERTEX_2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_VERTEX_3D[] = {  {&_swigt__p_p__dwg_entity_VERTEX_3D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_VERTEX_PFACE_FACE[] = {  {&_swigt__p_p__dwg_entity_VERTEX_PFACE_FACE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_VIEWPORT[] = {  {&_swigt__p_p__dwg_entity_VIEWPORT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_entity_WIPEOUT[] = {  {&_swigt__p_p__dwg_entity_WIPEOUT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_BOOLEAN_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_BOOLEAN_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_BOX_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_BOX_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_BREP_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_BREP_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_CHAMFER_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_CHAMFER_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_CONE_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_CONE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_CYLINDER_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_CYLINDER_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_FILLET_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_FILLET_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_HISTORY_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_HISTORY_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_PYRAMID_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_PYRAMID_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_SPHERE_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_SPHERE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_TORUS_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_TORUS_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ACSH_WEDGE_CLASS[] = {  {&_swigt__p_p__dwg_object_ACSH_WEDGE_CLASS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ALDIMOBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_ALDIMOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_APPID[] = {  {&_swigt__p_p__dwg_object_APPID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_APPID_CONTROL[] = {  {&_swigt__p_p__dwg_object_APPID_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOC2DCONSTRAINTGROUP[] = {  {&_swigt__p_p__dwg_object_ASSOC2DCONSTRAINTGROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCACTION[] = {  {&_swigt__p_p__dwg_object_ASSOCACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCARRAYACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCARRAYACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCASMBODYACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCASMBODYACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCDEPENDENCY[] = {  {&_swigt__p_p__dwg_object_ASSOCDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCDIMDEPENDENCYBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCDIMDEPENDENCYBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCFACEACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCFACEACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCGEOMDEPENDENCY[] = {  {&_swigt__p_p__dwg_object_ASSOCGEOMDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCNETWORK[] = {  {&_swigt__p_p__dwg_object_ASSOCNETWORK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCOBJECTACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCOBJECTACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCPATHACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCPATHACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCPOINTREFACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCPOINTREFACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY[] = {  {&_swigt__p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCVALUEDEPENDENCY[] = {  {&_swigt__p_p__dwg_object_ASSOCVALUEDEPENDENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCVARIABLE[] = {  {&_swigt__p_p__dwg_object_ASSOCVARIABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ASSOCVERTEXACTIONPARAM[] = {  {&_swigt__p_p__dwg_object_ASSOCVERTEXACTIONPARAM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLKREFOBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_BLKREFOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKALIGNMENTGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKALIGNMENTGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKALIGNMENTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKALIGNMENTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKARRAYACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKARRAYACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKBASEPOINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKBASEPOINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKFLIPACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKFLIPACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKFLIPGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKFLIPGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKFLIPPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKFLIPPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT[] = {  {&_swigt__p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLINEARGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKLINEARGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLINEARPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKLINEARPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLOOKUPACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKLOOKUPACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLOOKUPGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKLOOKUPGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKLOOKUPPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKLOOKUPPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKMOVEACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKMOVEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY[] = {  {&_swigt__p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKPOINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKPOINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKPOLARGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKPOLARGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKPOLARPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKPOLARPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKPOLARSTRETCHACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKPOLARSTRETCHACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKREPRESENTATION[] = {  {&_swigt__p_p__dwg_object_BLOCKREPRESENTATION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKROTATEACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKROTATEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKROTATIONGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKROTATIONGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKROTATIONPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKROTATIONPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKSCALEACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKSCALEACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKSTRETCHACTION[] = {  {&_swigt__p_p__dwg_object_BLOCKSTRETCHACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKUSERPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKUSERPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKVISIBILITYGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKVISIBILITYGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKVISIBILITYPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKVISIBILITYPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKXYGRIP[] = {  {&_swigt__p_p__dwg_object_BLOCKXYGRIP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCKXYPARAMETER[] = {  {&_swigt__p_p__dwg_object_BLOCKXYPARAMETER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCK_CONTROL[] = {  {&_swigt__p_p__dwg_object_BLOCK_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_BLOCK_HEADER[] = {  {&_swigt__p_p__dwg_object_BLOCK_HEADER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_CELLSTYLEMAP[] = {  {&_swigt__p_p__dwg_object_CELLSTYLEMAP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DATALINK[] = {  {&_swigt__p_p__dwg_object_DATALINK, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DBCOLOR[] = {  {&_swigt__p_p__dwg_object_DBCOLOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DETAILVIEWSTYLE[] = {  {&_swigt__p_p__dwg_object_DETAILVIEWSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DICTIONARY[] = {  {&_swigt__p_p__dwg_object_DICTIONARY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DICTIONARYVAR[] = {  {&_swigt__p_p__dwg_object_DICTIONARYVAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DICTIONARYWDFLT[] = {  {&_swigt__p_p__dwg_object_DICTIONARYWDFLT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DIMSTYLE[] = {  {&_swigt__p_p__dwg_object_DIMSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DIMSTYLE_CONTROL[] = {  {&_swigt__p_p__dwg_object_DIMSTYLE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DUMMY[] = {  {&_swigt__p_p__dwg_object_DUMMY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER[] = {  {&_swigt__p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_EVALUATION_GRAPH[] = {  {&_swigt__p_p__dwg_object_EVALUATION_GRAPH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_FCFOBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_FCFOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_FIELD[] = {  {&_swigt__p_p__dwg_object_FIELD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_FIELDLIST[] = {  {&_swigt__p_p__dwg_object_FIELDLIST, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_GEODATA[] = {  {&_swigt__p_p__dwg_object_GEODATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_GRADIENT_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_GRADIENT_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_GROUND_PLANE_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_GROUND_PLANE_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_GROUP[] = {  {&_swigt__p_p__dwg_object_GROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_IBL_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_IBL_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_IDBUFFER[] = {  {&_swigt__p_p__dwg_object_IDBUFFER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_IMAGEDEF[] = {  {&_swigt__p_p__dwg_object_IMAGEDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_IMAGEDEF_REACTOR[] = {  {&_swigt__p_p__dwg_object_IMAGEDEF_REACTOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_IMAGE_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_IMAGE_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_INDEX[] = {  {&_swigt__p_p__dwg_object_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LAYER[] = {  {&_swigt__p_p__dwg_object_LAYER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LAYERFILTER[] = {  {&_swigt__p_p__dwg_object_LAYERFILTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LAYER_CONTROL[] = {  {&_swigt__p_p__dwg_object_LAYER_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LAYER_INDEX[] = {  {&_swigt__p_p__dwg_object_LAYER_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LAYOUT[] = {  {&_swigt__p_p__dwg_object_LAYOUT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LEADEROBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_LEADEROBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LIGHTLIST[] = {  {&_swigt__p_p__dwg_object_LIGHTLIST, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LONG_TRANSACTION[] = {  {&_swigt__p_p__dwg_object_LONG_TRANSACTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LTYPE[] = {  {&_swigt__p_p__dwg_object_LTYPE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_LTYPE_CONTROL[] = {  {&_swigt__p_p__dwg_object_LTYPE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_MATERIAL[] = {  {&_swigt__p_p__dwg_object_MATERIAL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_MENTALRAYRENDERSETTINGS[] = {  {&_swigt__p_p__dwg_object_MENTALRAYRENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_MLEADERSTYLE[] = {  {&_swigt__p_p__dwg_object_MLEADERSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_MLINESTYLE[] = {  {&_swigt__p_p__dwg_object_MLINESTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_MTEXTOBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_MTEXTOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_OBJECT_PTR[] = {  {&_swigt__p_p__dwg_object_OBJECT_PTR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_PARTIAL_VIEWING_INDEX[] = {  {&_swigt__p_p__dwg_object_PARTIAL_VIEWING_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_PLACEHOLDER[] = {  {&_swigt__p_p__dwg_object_PLACEHOLDER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_PLOTSETTINGS[] = {  {&_swigt__p_p__dwg_object_PLOTSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_POINTCLOUDCOLORMAP[] = {  {&_swigt__p_p__dwg_object_POINTCLOUDCOLORMAP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_POINTCLOUDDEF[] = {  {&_swigt__p_p__dwg_object_POINTCLOUDDEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_POINTCLOUDDEFEX[] = {  {&_swigt__p_p__dwg_object_POINTCLOUDDEFEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_POINTCLOUDDEF_REACTOR[] = {  {&_swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX[] = {  {&_swigt__p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_PROXY_OBJECT[] = {  {&_swigt__p_p__dwg_object_PROXY_OBJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RAPIDRTRENDERSETTINGS[] = {  {&_swigt__p_p__dwg_object_RAPIDRTRENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RASTERVARIABLES[] = {  {&_swigt__p_p__dwg_object_RASTERVARIABLES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RENDERENTRY[] = {  {&_swigt__p_p__dwg_object_RENDERENTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RENDERENVIRONMENT[] = {  {&_swigt__p_p__dwg_object_RENDERENVIRONMENT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RENDERGLOBAL[] = {  {&_swigt__p_p__dwg_object_RENDERGLOBAL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_RENDERSETTINGS[] = {  {&_swigt__p_p__dwg_object_RENDERSETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SCALE[] = {  {&_swigt__p_p__dwg_object_SCALE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SECTIONVIEWSTYLE[] = {  {&_swigt__p_p__dwg_object_SECTIONVIEWSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SECTION_MANAGER[] = {  {&_swigt__p_p__dwg_object_SECTION_MANAGER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SECTION_SETTINGS[] = {  {&_swigt__p_p__dwg_object_SECTION_SETTINGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SKYLIGHT_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_SKYLIGHT_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SOLID_BACKGROUND[] = {  {&_swigt__p_p__dwg_object_SOLID_BACKGROUND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SORTENTSTABLE[] = {  {&_swigt__p_p__dwg_object_SORTENTSTABLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SPATIAL_FILTER[] = {  {&_swigt__p_p__dwg_object_SPATIAL_FILTER, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SPATIAL_INDEX[] = {  {&_swigt__p_p__dwg_object_SPATIAL_INDEX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_STYLE[] = {  {&_swigt__p_p__dwg_object_STYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_STYLE_CONTROL[] = {  {&_swigt__p_p__dwg_object_STYLE_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_SUN[] = {  {&_swigt__p_p__dwg_object_SUN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_TABLEGEOMETRY[] = {  {&_swigt__p_p__dwg_object_TABLEGEOMETRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_TABLESTYLE[] = {  {&_swigt__p_p__dwg_object_TABLESTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_TEXTOBJECTCONTEXTDATA[] = {  {&_swigt__p_p__dwg_object_TEXTOBJECTCONTEXTDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_UCS[] = {  {&_swigt__p_p__dwg_object_UCS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_UCS_CONTROL[] = {  {&_swigt__p_p__dwg_object_UCS_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_UNKNOWN_OBJ[] = {  {&_swigt__p_p__dwg_object_UNKNOWN_OBJ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VBA_PROJECT[] = {  {&_swigt__p_p__dwg_object_VBA_PROJECT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VIEW[] = {  {&_swigt__p_p__dwg_object_VIEW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VIEW_CONTROL[] = {  {&_swigt__p_p__dwg_object_VIEW_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VISUALSTYLE[] = {  {&_swigt__p_p__dwg_object_VISUALSTYLE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VPORT[] = {  {&_swigt__p_p__dwg_object_VPORT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VPORT_CONTROL[] = {  {&_swigt__p_p__dwg_object_VPORT_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VX_CONTROL[] = {  {&_swigt__p_p__dwg_object_VX_CONTROL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_VX_TABLE_RECORD[] = {  {&_swigt__p_p__dwg_object_VX_TABLE_RECORD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_WIPEOUTVARIABLES[] = {  {&_swigt__p_p__dwg_object_WIPEOUTVARIABLES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_XRECORD[] = {  {&_swigt__p_p__dwg_object_XRECORD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_entity[] = {  {&_swigt__p_p__dwg_object_entity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_object_ref[] = {  {&_swigt__p_p__dwg_object_ref, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__dwg_section[] = {  {&_swigt__p_p__dwg_section, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_r2007_file_header[] = {  {&_swigt__p_r2007_file_header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rgbpalette[] = {  {&_swigt__p_rgbpalette, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_DWG_CLASS_STABILITY,
  _swigc__p_DWG_COLOR_METHOD,
  _swigc__p_DWG_ENTITY_SECTIONS,
  _swigc__p_DWG_ERROR,
  _swigc__p_DWG_HDL_CODE,
  _swigc__p_DWG_OBJECT_SUPERTYPE,
  _swigc__p_DWG_OBJECT_TYPE,
  _swigc__p_DWG_OBJECT_TYPE_R11,
  _swigc__p_DWG_SECTION_TYPE,
  _swigc__p_DWG_SECTION_TYPE_R11,
  _swigc__p_DWG_SECTION_TYPE_R13,
  _swigc__p_DWG_VERSION_TYPE,
  _swigc__p_Dwg_Section_Info,
  _swigc__p_Dwg_Section_InfoHdr,
  _swigc__p_RESBUF_VALUE_TYPE,
  _swigc__p__dwg_3DSOLID_material,
  _swigc__p__dwg_3DSOLID_silhouette,
  _swigc__p__dwg_3DSOLID_wire,
  _swigc__p__dwg_ACSH_HistoryNode,
  _swigc__p__dwg_ACSH_SubentColor,
  _swigc__p__dwg_ACSH_SubentMaterial,
  _swigc__p__dwg_ACTIONBODY,
  _swigc__p__dwg_ARRAYITEMLOCATOR,
  _swigc__p__dwg_ASSOCACTIONBODY_action,
  _swigc__p__dwg_ASSOCACTION_Deps,
  _swigc__p__dwg_ASSOCARRAYITEM,
  _swigc__p__dwg_ASSOCPARAMBASEDACTIONBODY,
  _swigc__p__dwg_ASSOCSURFACEACTIONBODY,
  _swigc__p__dwg_AcDbMTextObjectEmbedded,
  _swigc__p__dwg_AcDs,
  _swigc__p__dwg_AcDs_Data,
  _swigc__p__dwg_AcDs_DataBlob,
  _swigc__p__dwg_AcDs_DataBlob01,
  _swigc__p__dwg_AcDs_DataBlobRef,
  _swigc__p__dwg_AcDs_DataBlobRef_Page,
  _swigc__p__dwg_AcDs_DataIndex,
  _swigc__p__dwg_AcDs_DataIndex_Entry,
  _swigc__p__dwg_AcDs_Data_Record,
  _swigc__p__dwg_AcDs_Data_RecordHdr,
  _swigc__p__dwg_AcDs_Schema,
  _swigc__p__dwg_AcDs_SchemaData,
  _swigc__p__dwg_AcDs_SchemaData_UProp,
  _swigc__p__dwg_AcDs_SchemaIndex,
  _swigc__p__dwg_AcDs_SchemaIndex_Prop,
  _swigc__p__dwg_AcDs_Schema_Prop,
  _swigc__p__dwg_AcDs_Search,
  _swigc__p__dwg_AcDs_Search_Data,
  _swigc__p__dwg_AcDs_Search_IdIdx,
  _swigc__p__dwg_AcDs_Search_IdIdxs,
  _swigc__p__dwg_AcDs_Segment,
  _swigc__p__dwg_AcDs_SegmentIndex,
  _swigc__p__dwg_BLOCKACTION_connectionpts,
  _swigc__p__dwg_BLOCKLOOKUPACTION_lut,
  _swigc__p__dwg_BLOCKPARAMETER_PropInfo,
  _swigc__p__dwg_BLOCKPARAMETER_connection,
  _swigc__p__dwg_BLOCKPARAMVALUESET,
  _swigc__p__dwg_BLOCKSTRETCHACTION_codes,
  _swigc__p__dwg_BLOCKSTRETCHACTION_handles,
  _swigc__p__dwg_BLOCKVISIBILITYPARAMETER_state,
  _swigc__p__dwg_COMPOUNDOBJECTID,
  _swigc__p__dwg_CONSTRAINTGROUPNODE,
  _swigc__p__dwg_CONTEXTDATA_dict,
  _swigc__p__dwg_CONTEXTDATA_submgr,
  _swigc__p__dwg_CellContentGeometry,
  _swigc__p__dwg_CellStyle,
  _swigc__p__dwg_ColorRamp,
  _swigc__p__dwg_ContentFormat,
  _swigc__p__dwg_DATALINK_customdata,
  _swigc__p__dwg_DATATABLE_column,
  _swigc__p__dwg_DATATABLE_row,
  _swigc__p__dwg_DIMASSOC_Ref,
  _swigc__p__dwg_DIMENSION_common,
  _swigc__p__dwg_EVAL_Edge,
  _swigc__p__dwg_EVAL_Node,
  _swigc__p__dwg_EvalExpr,
  _swigc__p__dwg_EvalExpr_value,
  _swigc__p__dwg_EvalVariant,
  _swigc__p__dwg_EvalVariant_u,
  _swigc__p__dwg_FIELD_ChildValue,
  _swigc__p__dwg_FileDepList_Files,
  _swigc__p__dwg_FormattedTableData,
  _swigc__p__dwg_FormattedTableMerged,
  _swigc__p__dwg_GEODATA_meshface,
  _swigc__p__dwg_GEODATA_meshpt,
  _swigc__p__dwg_GridFormat,
  _swigc__p__dwg_HATCH_Color,
  _swigc__p__dwg_HATCH_ControlPoint,
  _swigc__p__dwg_HATCH_DefLine,
  _swigc__p__dwg_HATCH_Path,
  _swigc__p__dwg_HATCH_PathSeg,
  _swigc__p__dwg_HATCH_PolylinePath,
  _swigc__p__dwg_LAYER_entry,
  _swigc__p__dwg_LEADER_ArrowHead,
  _swigc__p__dwg_LEADER_BlockLabel,
  _swigc__p__dwg_LEADER_Break,
  _swigc__p__dwg_LEADER_Line,
  _swigc__p__dwg_LEADER_Node,
  _swigc__p__dwg_LIGHTLIST_light,
  _swigc__p__dwg_LTYPE_dash,
  _swigc__p__dwg_LWPOLYLINE_width,
  _swigc__p__dwg_LinkedData,
  _swigc__p__dwg_LinkedTableData,
  _swigc__p__dwg_MATERIAL_color,
  _swigc__p__dwg_MATERIAL_gentexture,
  _swigc__p__dwg_MATERIAL_mapper,
  _swigc__p__dwg_MESH_edge,
  _swigc__p__dwg_MLEADER_AnnotContext,
  _swigc__p__dwg_MLEADER_Content,
  _swigc__p__dwg_MLEADER_Content_Block,
  _swigc__p__dwg_MLEADER_Content_MText,
  _swigc__p__dwg_MLINESTYLE_line,
  _swigc__p__dwg_MLINESTYLE_line_lt,
  _swigc__p__dwg_MLINE_line,
  _swigc__p__dwg_MLINE_vertex,
  _swigc__p__dwg_OCD_Dimension,
  _swigc__p__dwg_PARTIAL_VIEWING_INDEX_Entry,
  _swigc__p__dwg_POINTCLOUDCOLORMAP_Ramp,
  _swigc__p__dwg_POINTCLOUDEX_Croppings,
  _swigc__p__dwg_POINTCLOUD_Clippings,
  _swigc__p__dwg_POINTCLOUD_IntensityStyle,
  _swigc__p__dwg_PROXY_LWPOLYLINE,
  _swigc__p__dwg_R2004_Header,
  _swigc__p__dwg_SECTION_geometrysettings,
  _swigc__p__dwg_SECTION_typesettings,
  _swigc__p__dwg_SPLINE_control_point,
  _swigc__p__dwg_SUNSTUDY_Dates,
  _swigc__p__dwg_SummaryInfo_Property,
  _swigc__p__dwg_TABLEGEOMETRY_Cell,
  _swigc__p__dwg_TABLESTYLE_CellStyle,
  _swigc__p__dwg_TABLESTYLE_border,
  _swigc__p__dwg_TABLESTYLE_rowstyles,
  _swigc__p__dwg_TABLE_AttrDef,
  _swigc__p__dwg_TABLE_BreakHeight,
  _swigc__p__dwg_TABLE_BreakRow,
  _swigc__p__dwg_TABLE_Cell,
  _swigc__p__dwg_TABLE_CustomDataItem,
  _swigc__p__dwg_TABLE_value,
  _swigc__p__dwg_TableCell,
  _swigc__p__dwg_TableCellContent,
  _swigc__p__dwg_TableCellContent_Attr,
  _swigc__p__dwg_TableDataColumn,
  _swigc__p__dwg_TableRow,
  _swigc__p__dwg_UCS_orthopts,
  _swigc__p__dwg_VALUEPARAM,
  _swigc__p__dwg_VALUEPARAM_vars,
  _swigc__p__dwg_abstractentity_UNDERLAY,
  _swigc__p__dwg_abstractobject_ASSOCARRAYPARAMETERS,
  _swigc__p__dwg_abstractobject_UNDERLAYDEFINITION,
  _swigc__p__dwg_appinfo,
  _swigc__p__dwg_appinfohistory,
  _swigc__p__dwg_auxheader,
  _swigc__p__dwg_binary_chunk,
  _swigc__p__dwg_binary_chunk_u,
  _swigc__p__dwg_bitcode_2bd,
  _swigc__p__dwg_bitcode_2rd,
  _swigc__p__dwg_bitcode_3bd,
  _swigc__p__dwg_bitcode_3rd,
  _swigc__p__dwg_chain,
  _swigc__p__dwg_class,
  _swigc__p__dwg_color,
  _swigc__p__dwg_entity_3DFACE,
  _swigc__p__dwg_entity_3DLINE,
  _swigc__p__dwg_entity_3DSOLID,
  _swigc__p__dwg_entity_ALIGNMENTPARAMETERENTITY,
  _swigc__p__dwg_entity_ARC,
  _swigc__p__dwg_entity_ARCALIGNEDTEXT,
  _swigc__p__dwg_entity_ARC_DIMENSION,
  _swigc__p__dwg_entity_ATTDEF,
  _swigc__p__dwg_entity_ATTRIB,
  _swigc__p__dwg_entity_BASEPOINTPARAMETERENTITY,
  _swigc__p__dwg_entity_BLOCK,
  _swigc__p__dwg_entity_CAMERA,
  _swigc__p__dwg_entity_CIRCLE,
  _swigc__p__dwg_entity_DIMENSION_ALIGNED,
  _swigc__p__dwg_entity_DIMENSION_ANG2LN,
  _swigc__p__dwg_entity_DIMENSION_ANG3PT,
  _swigc__p__dwg_entity_DIMENSION_DIAMETER,
  _swigc__p__dwg_entity_DIMENSION_LINEAR,
  _swigc__p__dwg_entity_DIMENSION_ORDINATE,
  _swigc__p__dwg_entity_DIMENSION_RADIUS,
  _swigc__p__dwg_entity_ELLIPSE,
  _swigc__p__dwg_entity_ENDBLK,
  _swigc__p__dwg_entity_ENDREP,
  _swigc__p__dwg_entity_EXTRUDEDSURFACE,
  _swigc__p__dwg_entity_FLIPGRIPENTITY,
  _swigc__p__dwg_entity_FLIPPARAMETERENTITY,
  _swigc__p__dwg_entity_GEOPOSITIONMARKER,
  _swigc__p__dwg_entity_HATCH,
  _swigc__p__dwg_entity_HELIX,
  _swigc__p__dwg_entity_IMAGE,
  _swigc__p__dwg_entity_INSERT,
  _swigc__p__dwg_entity_JUMP,
  _swigc__p__dwg_entity_LARGE_RADIAL_DIMENSION,
  _swigc__p__dwg_entity_LAYOUTPRINTCONFIG,
  _swigc__p__dwg_entity_LEADER,
  _swigc__p__dwg_entity_LIGHT,
  _swigc__p__dwg_entity_LINE,
  _swigc__p__dwg_entity_LINEARGRIPENTITY,
  _swigc__p__dwg_entity_LINEARPARAMETERENTITY,
  _swigc__p__dwg_entity_LOAD,
  _swigc__p__dwg_entity_LOFTEDSURFACE,
  _swigc__p__dwg_entity_LWPOLYLINE,
  _swigc__p__dwg_entity_MESH,
  _swigc__p__dwg_entity_MINSERT,
  _swigc__p__dwg_entity_MLINE,
  _swigc__p__dwg_entity_MPOLYGON,
  _swigc__p__dwg_entity_MTEXT,
  _swigc__p__dwg_entity_MULTILEADER,
  _swigc__p__dwg_entity_NAVISWORKSMODEL,
  _swigc__p__dwg_entity_NURBSURFACE,
  _swigc__p__dwg_entity_OLE2FRAME,
  _swigc__p__dwg_entity_OLEFRAME,
  _swigc__p__dwg_entity_PLANESURFACE,
  _swigc__p__dwg_entity_POINT,
  _swigc__p__dwg_entity_POINTCLOUD,
  _swigc__p__dwg_entity_POINTCLOUDEX,
  _swigc__p__dwg_entity_POINTPARAMETERENTITY,
  _swigc__p__dwg_entity_POLARGRIPENTITY,
  _swigc__p__dwg_entity_POLYLINE_2D,
  _swigc__p__dwg_entity_POLYLINE_3D,
  _swigc__p__dwg_entity_POLYLINE_MESH,
  _swigc__p__dwg_entity_POLYLINE_PFACE,
  _swigc__p__dwg_entity_PROXY_ENTITY,
  _swigc__p__dwg_entity_RAY,
  _swigc__p__dwg_entity_REPEAT,
  _swigc__p__dwg_entity_REVOLVEDSURFACE,
  _swigc__p__dwg_entity_ROTATIONGRIPENTITY,
  _swigc__p__dwg_entity_ROTATIONPARAMETERENTITY,
  _swigc__p__dwg_entity_RTEXT,
  _swigc__p__dwg_entity_SECTIONOBJECT,
  _swigc__p__dwg_entity_SEQEND,
  _swigc__p__dwg_entity_SHAPE,
  _swigc__p__dwg_entity_SOLID,
  _swigc__p__dwg_entity_SPLINE,
  _swigc__p__dwg_entity_SWEPTSURFACE,
  _swigc__p__dwg_entity_TABLE,
  _swigc__p__dwg_entity_TEXT,
  _swigc__p__dwg_entity_TOLERANCE,
  _swigc__p__dwg_entity_TRACE,
  _swigc__p__dwg_entity_UNKNOWN_ENT,
  _swigc__p__dwg_entity_VERTEX_2D,
  _swigc__p__dwg_entity_VERTEX_3D,
  _swigc__p__dwg_entity_VERTEX_PFACE_FACE,
  _swigc__p__dwg_entity_VIEWPORT,
  _swigc__p__dwg_entity_VISIBILITYGRIPENTITY,
  _swigc__p__dwg_entity_VISIBILITYPARAMETERENTITY,
  _swigc__p__dwg_entity_WIPEOUT,
  _swigc__p__dwg_entity_XYGRIPENTITY,
  _swigc__p__dwg_entity_XYPARAMETERENTITY,
  _swigc__p__dwg_entity_eed,
  _swigc__p__dwg_entity_eed_data,
  _swigc__p__dwg_filedeplist,
  _swigc__p__dwg_handle,
  _swigc__p__dwg_header,
  _swigc__p__dwg_header_variables,
  _swigc__p__dwg_object,
  _swigc__p__dwg_object_ACMECOMMANDHISTORY,
  _swigc__p__dwg_object_ACMESCOPE,
  _swigc__p__dwg_object_ACMESTATEMGR,
  _swigc__p__dwg_object_ACSH_BOOLEAN_CLASS,
  _swigc__p__dwg_object_ACSH_BOX_CLASS,
  _swigc__p__dwg_object_ACSH_BREP_CLASS,
  _swigc__p__dwg_object_ACSH_CHAMFER_CLASS,
  _swigc__p__dwg_object_ACSH_CONE_CLASS,
  _swigc__p__dwg_object_ACSH_CYLINDER_CLASS,
  _swigc__p__dwg_object_ACSH_EXTRUSION_CLASS,
  _swigc__p__dwg_object_ACSH_FILLET_CLASS,
  _swigc__p__dwg_object_ACSH_HISTORY_CLASS,
  _swigc__p__dwg_object_ACSH_LOFT_CLASS,
  _swigc__p__dwg_object_ACSH_PYRAMID_CLASS,
  _swigc__p__dwg_object_ACSH_REVOLVE_CLASS,
  _swigc__p__dwg_object_ACSH_SPHERE_CLASS,
  _swigc__p__dwg_object_ACSH_SWEEP_CLASS,
  _swigc__p__dwg_object_ACSH_TORUS_CLASS,
  _swigc__p__dwg_object_ACSH_WEDGE_CLASS,
  _swigc__p__dwg_object_ALDIMOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_ANGDIMOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_ANNOTSCALEOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_APPID,
  _swigc__p__dwg_object_APPID_CONTROL,
  _swigc__p__dwg_object_ASSOC2DCONSTRAINTGROUP,
  _swigc__p__dwg_object_ASSOC3POINTANGULARDIMACTIONBODY,
  _swigc__p__dwg_object_ASSOCACTION,
  _swigc__p__dwg_object_ASSOCACTIONPARAM,
  _swigc__p__dwg_object_ASSOCALIGNEDDIMACTIONBODY,
  _swigc__p__dwg_object_ASSOCARRAYACTIONBODY,
  _swigc__p__dwg_object_ASSOCARRAYMODIFYACTIONBODY,
  _swigc__p__dwg_object_ASSOCASMBODYACTIONPARAM,
  _swigc__p__dwg_object_ASSOCBLENDSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCCOMPOUNDACTIONPARAM,
  _swigc__p__dwg_object_ASSOCDEPENDENCY,
  _swigc__p__dwg_object_ASSOCDIMDEPENDENCYBODY,
  _swigc__p__dwg_object_ASSOCEDGEACTIONPARAM,
  _swigc__p__dwg_object_ASSOCEDGECHAMFERACTIONBODY,
  _swigc__p__dwg_object_ASSOCEDGEFILLETACTIONBODY,
  _swigc__p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCFACEACTIONPARAM,
  _swigc__p__dwg_object_ASSOCFILLETSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCGEOMDEPENDENCY,
  _swigc__p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCMLEADERACTIONBODY,
  _swigc__p__dwg_object_ASSOCNETWORK,
  _swigc__p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCOBJECTACTIONPARAM,
  _swigc__p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCORDINATEDIMACTIONBODY,
  _swigc__p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM,
  _swigc__p__dwg_object_ASSOCPATCHSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCPATHACTIONPARAM,
  _swigc__p__dwg_object_ASSOCPERSSUBENTMANAGER,
  _swigc__p__dwg_object_ASSOCPLANESURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCPOINTREFACTIONPARAM,
  _swigc__p__dwg_object_ASSOCRESTOREENTITYSTATEACTIONBODY,
  _swigc__p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCROTATEDDIMACTIONBODY,
  _swigc__p__dwg_object_ASSOCSWEPTSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCTRIMSURFACEACTIONBODY,
  _swigc__p__dwg_object_ASSOCVALUEDEPENDENCY,
  _swigc__p__dwg_object_ASSOCVARIABLE,
  _swigc__p__dwg_object_ASSOCVERTEXACTIONPARAM,
  _swigc__p__dwg_object_BLKREFOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKALIGNMENTGRIP,
  _swigc__p__dwg_object_BLOCKALIGNMENTPARAMETER,
  _swigc__p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKARRAYACTION,
  _swigc__p__dwg_object_BLOCKBASEPOINTPARAMETER,
  _swigc__p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKFLIPACTION,
  _swigc__p__dwg_object_BLOCKFLIPGRIP,
  _swigc__p__dwg_object_BLOCKFLIPPARAMETER,
  _swigc__p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT,
  _swigc__p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKLINEARGRIP,
  _swigc__p__dwg_object_BLOCKLINEARPARAMETER,
  _swigc__p__dwg_object_BLOCKLOOKUPACTION,
  _swigc__p__dwg_object_BLOCKLOOKUPGRIP,
  _swigc__p__dwg_object_BLOCKLOOKUPPARAMETER,
  _swigc__p__dwg_object_BLOCKMOVEACTION,
  _swigc__p__dwg_object_BLOCKPARAMDEPENDENCYBODY,
  _swigc__p__dwg_object_BLOCKPOINTPARAMETER,
  _swigc__p__dwg_object_BLOCKPOLARGRIP,
  _swigc__p__dwg_object_BLOCKPOLARPARAMETER,
  _swigc__p__dwg_object_BLOCKPOLARSTRETCHACTION,
  _swigc__p__dwg_object_BLOCKPROPERTIESTABLE,
  _swigc__p__dwg_object_BLOCKPROPERTIESTABLEGRIP,
  _swigc__p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKREPRESENTATION,
  _swigc__p__dwg_object_BLOCKROTATEACTION,
  _swigc__p__dwg_object_BLOCKROTATIONGRIP,
  _swigc__p__dwg_object_BLOCKROTATIONPARAMETER,
  _swigc__p__dwg_object_BLOCKSCALEACTION,
  _swigc__p__dwg_object_BLOCKSTRETCHACTION,
  _swigc__p__dwg_object_BLOCKUSERPARAMETER,
  _swigc__p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER,
  _swigc__p__dwg_object_BLOCKVISIBILITYGRIP,
  _swigc__p__dwg_object_BLOCKVISIBILITYPARAMETER,
  _swigc__p__dwg_object_BLOCKXYGRIP,
  _swigc__p__dwg_object_BLOCKXYPARAMETER,
  _swigc__p__dwg_object_BLOCK_CONTROL,
  _swigc__p__dwg_object_BLOCK_HEADER,
  _swigc__p__dwg_object_BREAKDATA,
  _swigc__p__dwg_object_BREAKPOINTREF,
  _swigc__p__dwg_object_CELLSTYLEMAP,
  _swigc__p__dwg_object_CONTEXTDATAMANAGER,
  _swigc__p__dwg_object_CSACDOCUMENTOPTIONS,
  _swigc__p__dwg_object_CURVEPATH,
  _swigc__p__dwg_object_DATALINK,
  _swigc__p__dwg_object_DATATABLE,
  _swigc__p__dwg_object_DBCOLOR,
  _swigc__p__dwg_object_DETAILVIEWSTYLE,
  _swigc__p__dwg_object_DICTIONARY,
  _swigc__p__dwg_object_DICTIONARYVAR,
  _swigc__p__dwg_object_DICTIONARYWDFLT,
  _swigc__p__dwg_object_DIMASSOC,
  _swigc__p__dwg_object_DIMSTYLE,
  _swigc__p__dwg_object_DIMSTYLE_CONTROL,
  _swigc__p__dwg_object_DMDIMOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_DUMMY,
  _swigc__p__dwg_object_DYNAMICBLOCKPROXYNODE,
  _swigc__p__dwg_object_DYNAMICBLOCKPURGEPREVENTER,
  _swigc__p__dwg_object_EVALUATION_GRAPH,
  _swigc__p__dwg_object_FCFOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_FIELD,
  _swigc__p__dwg_object_FIELDLIST,
  _swigc__p__dwg_object_GEODATA,
  _swigc__p__dwg_object_GEOMAPIMAGE,
  _swigc__p__dwg_object_GRADIENT_BACKGROUND,
  _swigc__p__dwg_object_GROUND_PLANE_BACKGROUND,
  _swigc__p__dwg_object_GROUP,
  _swigc__p__dwg_object_IBL_BACKGROUND,
  _swigc__p__dwg_object_IDBUFFER,
  _swigc__p__dwg_object_IMAGEDEF,
  _swigc__p__dwg_object_IMAGEDEF_REACTOR,
  _swigc__p__dwg_object_IMAGE_BACKGROUND,
  _swigc__p__dwg_object_INDEX,
  _swigc__p__dwg_object_LAYER,
  _swigc__p__dwg_object_LAYERFILTER,
  _swigc__p__dwg_object_LAYER_CONTROL,
  _swigc__p__dwg_object_LAYER_INDEX,
  _swigc__p__dwg_object_LAYOUT,
  _swigc__p__dwg_object_LEADEROBJECTCONTEXTDATA,
  _swigc__p__dwg_object_LIGHTLIST,
  _swigc__p__dwg_object_LONG_TRANSACTION,
  _swigc__p__dwg_object_LTYPE,
  _swigc__p__dwg_object_LTYPE_CONTROL,
  _swigc__p__dwg_object_MATERIAL,
  _swigc__p__dwg_object_MENTALRAYRENDERSETTINGS,
  _swigc__p__dwg_object_MLEADEROBJECTCONTEXTDATA,
  _swigc__p__dwg_object_MLEADERSTYLE,
  _swigc__p__dwg_object_MLINESTYLE,
  _swigc__p__dwg_object_MOTIONPATH,
  _swigc__p__dwg_object_MTEXTATTRIBUTEOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_MTEXTOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_NAVISWORKSMODELDEF,
  _swigc__p__dwg_object_OBJECT_PTR,
  _swigc__p__dwg_object_ORDDIMOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_PARTIAL_VIEWING_INDEX,
  _swigc__p__dwg_object_PERSUBENTMGR,
  _swigc__p__dwg_object_PLACEHOLDER,
  _swigc__p__dwg_object_PLOTSETTINGS,
  _swigc__p__dwg_object_POINTCLOUDCOLORMAP,
  _swigc__p__dwg_object_POINTCLOUDDEF,
  _swigc__p__dwg_object_POINTCLOUDDEFEX,
  _swigc__p__dwg_object_POINTCLOUDDEF_REACTOR,
  _swigc__p__dwg_object_POINTCLOUDDEF_REACTOR_EX,
  _swigc__p__dwg_object_POINTPATH,
  _swigc__p__dwg_object_PROXY_OBJECT,
  _swigc__p__dwg_object_RADIMLGOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_RADIMOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_RAPIDRTRENDERSETTINGS,
  _swigc__p__dwg_object_RASTERVARIABLES,
  _swigc__p__dwg_object_RENDERENTRY,
  _swigc__p__dwg_object_RENDERENVIRONMENT,
  _swigc__p__dwg_object_RENDERGLOBAL,
  _swigc__p__dwg_object_RENDERSETTINGS,
  _swigc__p__dwg_object_SCALE,
  _swigc__p__dwg_object_SECTIONVIEWSTYLE,
  _swigc__p__dwg_object_SECTION_MANAGER,
  _swigc__p__dwg_object_SECTION_SETTINGS,
  _swigc__p__dwg_object_SKYLIGHT_BACKGROUND,
  _swigc__p__dwg_object_SOLID_BACKGROUND,
  _swigc__p__dwg_object_SORTENTSTABLE,
  _swigc__p__dwg_object_SPATIAL_FILTER,
  _swigc__p__dwg_object_SPATIAL_INDEX,
  _swigc__p__dwg_object_STYLE,
  _swigc__p__dwg_object_STYLE_CONTROL,
  _swigc__p__dwg_object_SUN,
  _swigc__p__dwg_object_SUNSTUDY,
  _swigc__p__dwg_object_TABLECONTENT,
  _swigc__p__dwg_object_TABLEGEOMETRY,
  _swigc__p__dwg_object_TABLESTYLE,
  _swigc__p__dwg_object_TEXTOBJECTCONTEXTDATA,
  _swigc__p__dwg_object_TVDEVICEPROPERTIES,
  _swigc__p__dwg_object_UCS,
  _swigc__p__dwg_object_UCS_CONTROL,
  _swigc__p__dwg_object_UNKNOWN_OBJ,
  _swigc__p__dwg_object_VBA_PROJECT,
  _swigc__p__dwg_object_VIEW,
  _swigc__p__dwg_object_VIEW_CONTROL,
  _swigc__p__dwg_object_VISUALSTYLE,
  _swigc__p__dwg_object_VPORT,
  _swigc__p__dwg_object_VPORT_CONTROL,
  _swigc__p__dwg_object_VX_CONTROL,
  _swigc__p__dwg_object_VX_TABLE_RECORD,
  _swigc__p__dwg_object_WIPEOUTVARIABLES,
  _swigc__p__dwg_object_XRECORD,
  _swigc__p__dwg_object_entity,
  _swigc__p__dwg_object_entity_tio,
  _swigc__p__dwg_object_object,
  _swigc__p__dwg_object_object_tio,
  _swigc__p__dwg_object_ref,
  _swigc__p__dwg_object_tio,
  _swigc__p__dwg_objfreespace,
  _swigc__p__dwg_resbuf,
  _swigc__p__dwg_resbuf_value,
  _swigc__p__dwg_revhistory,
  _swigc__p__dwg_secondheader,
  _swigc__p__dwg_secondheader_handles,
  _swigc__p__dwg_secondheader_sections,
  _swigc__p__dwg_section,
  _swigc__p__dwg_security,
  _swigc__p__dwg_struct,
  _swigc__p__dwg_struct_fhdr,
  _swigc__p__dwg_summaryinfo,
  _swigc__p__dwg_template,
  _swigc__p__dwg_time_bll,
  _swigc__p__dwg_vbaproject,
  _swigc__p__inthash,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_dwg_entity_DIMENSION_common,
  _swigc__p_dwg_field_name_type_offset,
  _swigc__p_dwg_obj_ent,
  _swigc__p_dwg_obj_generic,
  _swigc__p_dwg_obj_layer,
  _swigc__p_dwg_obj_obj,
  _swigc__p_dwg_object,
  _swigc__p_dwg_versions,
  _swigc__p_eed_data_t,
  _swigc__p_eed_data_t_eed_0,
  _swigc__p_eed_data_t_eed_0_r2007,
  _swigc__p_eed_data_t_eed_1,
  _swigc__p_eed_data_t_eed_10,
  _swigc__p_eed_data_t_eed_2,
  _swigc__p_eed_data_t_eed_3,
  _swigc__p_eed_data_t_eed_4,
  _swigc__p_eed_data_t_eed_40,
  _swigc__p_eed_data_t_eed_5,
  _swigc__p_eed_data_t_eed_70,
  _swigc__p_eed_data_t_eed_71,
  _swigc__p_int,
  _swigc__p_long_long,
  _swigc__p_p__dwg_abstractentity_UNDERLAY,
  _swigc__p_p__dwg_abstractobject_ASSOCARRAYPARAMETERS,
  _swigc__p_p__dwg_abstractobject_UNDERLAYDEFINITION,
  _swigc__p_p__dwg_entity_3DFACE,
  _swigc__p_p__dwg_entity_3DLINE,
  _swigc__p_p__dwg_entity_3DSOLID,
  _swigc__p_p__dwg_entity_ARC,
  _swigc__p_p__dwg_entity_ARC_DIMENSION,
  _swigc__p_p__dwg_entity_ATTDEF,
  _swigc__p_p__dwg_entity_ATTRIB,
  _swigc__p_p__dwg_entity_BLOCK,
  _swigc__p_p__dwg_entity_CAMERA,
  _swigc__p_p__dwg_entity_CIRCLE,
  _swigc__p_p__dwg_entity_DIMENSION_ALIGNED,
  _swigc__p_p__dwg_entity_DIMENSION_ANG2LN,
  _swigc__p_p__dwg_entity_DIMENSION_ANG3PT,
  _swigc__p_p__dwg_entity_DIMENSION_DIAMETER,
  _swigc__p_p__dwg_entity_DIMENSION_LINEAR,
  _swigc__p_p__dwg_entity_DIMENSION_ORDINATE,
  _swigc__p_p__dwg_entity_DIMENSION_RADIUS,
  _swigc__p_p__dwg_entity_ELLIPSE,
  _swigc__p_p__dwg_entity_ENDBLK,
  _swigc__p_p__dwg_entity_ENDREP,
  _swigc__p_p__dwg_entity_HATCH,
  _swigc__p_p__dwg_entity_HELIX,
  _swigc__p_p__dwg_entity_IMAGE,
  _swigc__p_p__dwg_entity_INSERT,
  _swigc__p_p__dwg_entity_JUMP,
  _swigc__p_p__dwg_entity_LARGE_RADIAL_DIMENSION,
  _swigc__p_p__dwg_entity_LAYOUTPRINTCONFIG,
  _swigc__p_p__dwg_entity_LEADER,
  _swigc__p_p__dwg_entity_LIGHT,
  _swigc__p_p__dwg_entity_LINE,
  _swigc__p_p__dwg_entity_LOAD,
  _swigc__p_p__dwg_entity_LWPOLYLINE,
  _swigc__p_p__dwg_entity_MESH,
  _swigc__p_p__dwg_entity_MINSERT,
  _swigc__p_p__dwg_entity_MLINE,
  _swigc__p_p__dwg_entity_MTEXT,
  _swigc__p_p__dwg_entity_MULTILEADER,
  _swigc__p_p__dwg_entity_OLE2FRAME,
  _swigc__p_p__dwg_entity_OLEFRAME,
  _swigc__p_p__dwg_entity_PLANESURFACE,
  _swigc__p_p__dwg_entity_POINT,
  _swigc__p_p__dwg_entity_POINTCLOUD,
  _swigc__p_p__dwg_entity_POINTCLOUDEX,
  _swigc__p_p__dwg_entity_POLYLINE_2D,
  _swigc__p_p__dwg_entity_POLYLINE_3D,
  _swigc__p_p__dwg_entity_POLYLINE_MESH,
  _swigc__p_p__dwg_entity_POLYLINE_PFACE,
  _swigc__p_p__dwg_entity_PROXY_ENTITY,
  _swigc__p_p__dwg_entity_RAY,
  _swigc__p_p__dwg_entity_REPEAT,
  _swigc__p_p__dwg_entity_SECTIONOBJECT,
  _swigc__p_p__dwg_entity_SEQEND,
  _swigc__p_p__dwg_entity_SHAPE,
  _swigc__p_p__dwg_entity_SOLID,
  _swigc__p_p__dwg_entity_SPLINE,
  _swigc__p_p__dwg_entity_TEXT,
  _swigc__p_p__dwg_entity_TOLERANCE,
  _swigc__p_p__dwg_entity_TRACE,
  _swigc__p_p__dwg_entity_UNKNOWN_ENT,
  _swigc__p_p__dwg_entity_VERTEX_2D,
  _swigc__p_p__dwg_entity_VERTEX_3D,
  _swigc__p_p__dwg_entity_VERTEX_PFACE_FACE,
  _swigc__p_p__dwg_entity_VIEWPORT,
  _swigc__p_p__dwg_entity_WIPEOUT,
  _swigc__p_p__dwg_object_ACSH_BOOLEAN_CLASS,
  _swigc__p_p__dwg_object_ACSH_BOX_CLASS,
  _swigc__p_p__dwg_object_ACSH_BREP_CLASS,
  _swigc__p_p__dwg_object_ACSH_CHAMFER_CLASS,
  _swigc__p_p__dwg_object_ACSH_CONE_CLASS,
  _swigc__p_p__dwg_object_ACSH_CYLINDER_CLASS,
  _swigc__p_p__dwg_object_ACSH_FILLET_CLASS,
  _swigc__p_p__dwg_object_ACSH_HISTORY_CLASS,
  _swigc__p_p__dwg_object_ACSH_PYRAMID_CLASS,
  _swigc__p_p__dwg_object_ACSH_SPHERE_CLASS,
  _swigc__p_p__dwg_object_ACSH_TORUS_CLASS,
  _swigc__p_p__dwg_object_ACSH_WEDGE_CLASS,
  _swigc__p_p__dwg_object_ALDIMOBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_APPID,
  _swigc__p_p__dwg_object_APPID_CONTROL,
  _swigc__p_p__dwg_object_ASSOC2DCONSTRAINTGROUP,
  _swigc__p_p__dwg_object_ASSOCACTION,
  _swigc__p_p__dwg_object_ASSOCACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCARRAYACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCASMBODYACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCBLENDSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCCOMPOUNDACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCDEPENDENCY,
  _swigc__p_p__dwg_object_ASSOCDIMDEPENDENCYBODY,
  _swigc__p_p__dwg_object_ASSOCEXTENDSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCEXTRUDEDSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCFACEACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCFILLETSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCGEOMDEPENDENCY,
  _swigc__p_p__dwg_object_ASSOCLOFTEDSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCNETWORK,
  _swigc__p_p__dwg_object_ASSOCNETWORKSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCOBJECTACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCOFFSETSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCOSNAPPOINTREFACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCPATCHSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCPATHACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCPLANESURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCPOINTREFACTIONPARAM,
  _swigc__p_p__dwg_object_ASSOCREVOLVEDSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCTRIMSURFACEACTIONBODY,
  _swigc__p_p__dwg_object_ASSOCVALUEDEPENDENCY,
  _swigc__p_p__dwg_object_ASSOCVARIABLE,
  _swigc__p_p__dwg_object_ASSOCVERTEXACTIONPARAM,
  _swigc__p_p__dwg_object_BLKREFOBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_BLOCKALIGNEDCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKALIGNMENTGRIP,
  _swigc__p_p__dwg_object_BLOCKALIGNMENTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKANGULARCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKARRAYACTION,
  _swigc__p_p__dwg_object_BLOCKBASEPOINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKDIAMETRICCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKFLIPACTION,
  _swigc__p_p__dwg_object_BLOCKFLIPGRIP,
  _swigc__p_p__dwg_object_BLOCKFLIPPARAMETER,
  _swigc__p_p__dwg_object_BLOCKGRIPLOCATIONCOMPONENT,
  _swigc__p_p__dwg_object_BLOCKHORIZONTALCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKLINEARCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKLINEARGRIP,
  _swigc__p_p__dwg_object_BLOCKLINEARPARAMETER,
  _swigc__p_p__dwg_object_BLOCKLOOKUPACTION,
  _swigc__p_p__dwg_object_BLOCKLOOKUPGRIP,
  _swigc__p_p__dwg_object_BLOCKLOOKUPPARAMETER,
  _swigc__p_p__dwg_object_BLOCKMOVEACTION,
  _swigc__p_p__dwg_object_BLOCKPARAMDEPENDENCYBODY,
  _swigc__p_p__dwg_object_BLOCKPOINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKPOLARGRIP,
  _swigc__p_p__dwg_object_BLOCKPOLARPARAMETER,
  _swigc__p_p__dwg_object_BLOCKPOLARSTRETCHACTION,
  _swigc__p_p__dwg_object_BLOCKRADIALCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKREPRESENTATION,
  _swigc__p_p__dwg_object_BLOCKROTATEACTION,
  _swigc__p_p__dwg_object_BLOCKROTATIONGRIP,
  _swigc__p_p__dwg_object_BLOCKROTATIONPARAMETER,
  _swigc__p_p__dwg_object_BLOCKSCALEACTION,
  _swigc__p_p__dwg_object_BLOCKSTRETCHACTION,
  _swigc__p_p__dwg_object_BLOCKUSERPARAMETER,
  _swigc__p_p__dwg_object_BLOCKVERTICALCONSTRAINTPARAMETER,
  _swigc__p_p__dwg_object_BLOCKVISIBILITYGRIP,
  _swigc__p_p__dwg_object_BLOCKVISIBILITYPARAMETER,
  _swigc__p_p__dwg_object_BLOCKXYGRIP,
  _swigc__p_p__dwg_object_BLOCKXYPARAMETER,
  _swigc__p_p__dwg_object_BLOCK_CONTROL,
  _swigc__p_p__dwg_object_BLOCK_HEADER,
  _swigc__p_p__dwg_object_CELLSTYLEMAP,
  _swigc__p_p__dwg_object_DATALINK,
  _swigc__p_p__dwg_object_DBCOLOR,
  _swigc__p_p__dwg_object_DETAILVIEWSTYLE,
  _swigc__p_p__dwg_object_DICTIONARY,
  _swigc__p_p__dwg_object_DICTIONARYVAR,
  _swigc__p_p__dwg_object_DICTIONARYWDFLT,
  _swigc__p_p__dwg_object_DIMSTYLE,
  _swigc__p_p__dwg_object_DIMSTYLE_CONTROL,
  _swigc__p_p__dwg_object_DUMMY,
  _swigc__p_p__dwg_object_DYNAMICBLOCKPURGEPREVENTER,
  _swigc__p_p__dwg_object_EVALUATION_GRAPH,
  _swigc__p_p__dwg_object_FCFOBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_FIELD,
  _swigc__p_p__dwg_object_FIELDLIST,
  _swigc__p_p__dwg_object_GEODATA,
  _swigc__p_p__dwg_object_GRADIENT_BACKGROUND,
  _swigc__p_p__dwg_object_GROUND_PLANE_BACKGROUND,
  _swigc__p_p__dwg_object_GROUP,
  _swigc__p_p__dwg_object_IBL_BACKGROUND,
  _swigc__p_p__dwg_object_IDBUFFER,
  _swigc__p_p__dwg_object_IMAGEDEF,
  _swigc__p_p__dwg_object_IMAGEDEF_REACTOR,
  _swigc__p_p__dwg_object_IMAGE_BACKGROUND,
  _swigc__p_p__dwg_object_INDEX,
  _swigc__p_p__dwg_object_LAYER,
  _swigc__p_p__dwg_object_LAYERFILTER,
  _swigc__p_p__dwg_object_LAYER_CONTROL,
  _swigc__p_p__dwg_object_LAYER_INDEX,
  _swigc__p_p__dwg_object_LAYOUT,
  _swigc__p_p__dwg_object_LEADEROBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_LIGHTLIST,
  _swigc__p_p__dwg_object_LONG_TRANSACTION,
  _swigc__p_p__dwg_object_LTYPE,
  _swigc__p_p__dwg_object_LTYPE_CONTROL,
  _swigc__p_p__dwg_object_MATERIAL,
  _swigc__p_p__dwg_object_MENTALRAYRENDERSETTINGS,
  _swigc__p_p__dwg_object_MLEADERSTYLE,
  _swigc__p_p__dwg_object_MLINESTYLE,
  _swigc__p_p__dwg_object_MTEXTOBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_OBJECT_PTR,
  _swigc__p_p__dwg_object_PARTIAL_VIEWING_INDEX,
  _swigc__p_p__dwg_object_PLACEHOLDER,
  _swigc__p_p__dwg_object_PLOTSETTINGS,
  _swigc__p_p__dwg_object_POINTCLOUDCOLORMAP,
  _swigc__p_p__dwg_object_POINTCLOUDDEF,
  _swigc__p_p__dwg_object_POINTCLOUDDEFEX,
  _swigc__p_p__dwg_object_POINTCLOUDDEF_REACTOR,
  _swigc__p_p__dwg_object_POINTCLOUDDEF_REACTOR_EX,
  _swigc__p_p__dwg_object_PROXY_OBJECT,
  _swigc__p_p__dwg_object_RAPIDRTRENDERSETTINGS,
  _swigc__p_p__dwg_object_RASTERVARIABLES,
  _swigc__p_p__dwg_object_RENDERENTRY,
  _swigc__p_p__dwg_object_RENDERENVIRONMENT,
  _swigc__p_p__dwg_object_RENDERGLOBAL,
  _swigc__p_p__dwg_object_RENDERSETTINGS,
  _swigc__p_p__dwg_object_SCALE,
  _swigc__p_p__dwg_object_SECTIONVIEWSTYLE,
  _swigc__p_p__dwg_object_SECTION_MANAGER,
  _swigc__p_p__dwg_object_SECTION_SETTINGS,
  _swigc__p_p__dwg_object_SKYLIGHT_BACKGROUND,
  _swigc__p_p__dwg_object_SOLID_BACKGROUND,
  _swigc__p_p__dwg_object_SORTENTSTABLE,
  _swigc__p_p__dwg_object_SPATIAL_FILTER,
  _swigc__p_p__dwg_object_SPATIAL_INDEX,
  _swigc__p_p__dwg_object_STYLE,
  _swigc__p_p__dwg_object_STYLE_CONTROL,
  _swigc__p_p__dwg_object_SUN,
  _swigc__p_p__dwg_object_TABLEGEOMETRY,
  _swigc__p_p__dwg_object_TABLESTYLE,
  _swigc__p_p__dwg_object_TEXTOBJECTCONTEXTDATA,
  _swigc__p_p__dwg_object_UCS,
  _swigc__p_p__dwg_object_UCS_CONTROL,
  _swigc__p_p__dwg_object_UNKNOWN_OBJ,
  _swigc__p_p__dwg_object_VBA_PROJECT,
  _swigc__p_p__dwg_object_VIEW,
  _swigc__p_p__dwg_object_VIEW_CONTROL,
  _swigc__p_p__dwg_object_VISUALSTYLE,
  _swigc__p_p__dwg_object_VPORT,
  _swigc__p_p__dwg_object_VPORT_CONTROL,
  _swigc__p_p__dwg_object_VX_CONTROL,
  _swigc__p_p__dwg_object_VX_TABLE_RECORD,
  _swigc__p_p__dwg_object_WIPEOUTVARIABLES,
  _swigc__p_p__dwg_object_XRECORD,
  _swigc__p_p__dwg_object_entity,
  _swigc__p_p__dwg_object_ref,
  _swigc__p_p__dwg_section,
  _swigc__p_p_char,
  _swigc__p_r2007_file_header,
  _swigc__p_rgbpalette,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  SWIG_Python_SetConstant(d, "LIBREDWG_VERSION_MAJOR",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "LIBREDWG_VERSION_MINOR",SWIG_From_int((int)(13)));
  SWIG_Python_SetConstant(d, "LIBREDWG_VERSION",SWIG_From_int((int)(((0*100)+13))));
  SWIG_Python_SetConstant(d, "FORMAT_RC",SWIG_FromCharPtr("0x%hhx"));
  SWIG_Python_SetConstant(d, "SCANF_2X",SWIG_FromCharPtr("%2hhX"));
  SWIG_Python_SetConstant(d, "FORMAT_RCd",SWIG_FromCharPtr("%d"));
  SWIG_Python_SetConstant(d, "FORMAT_RCu",SWIG_FromCharPtr("%u"));
  SWIG_Python_SetConstant(d, "FORMAT_RCx",SWIG_FromCharPtr("0x%x"));
  SWIG_Python_SetConstant(d, "FORMAT_B",SWIG_FromCharPtr("%d"));
  SWIG_Python_SetConstant(d, "FORMAT_BB",SWIG_FromCharPtr("%u"));
  SWIG_Python_SetConstant(d, "FORMAT_3B",SWIG_FromCharPtr("%u"));
  SWIG_Python_SetConstant(d, "FORMAT_RD",SWIG_FromCharPtr("%g"));
  SWIG_Python_SetConstant(d, "FORMAT_TF",SWIG_FromCharPtr("\"%s\""));
  SWIG_Python_SetConstant(d, "FORMAT_TV",SWIG_FromCharPtr("\"%s\""));
  SWIG_Python_SetConstant(d, "FORMAT_T16",SWIG_FromCharPtr("\"%s\""));
  SWIG_Python_SetConstant(d, "FORMAT_T32",SWIG_FromCharPtr("\"%s\""));
  SWIG_Python_SetConstant(d, "FORMAT_TU32",SWIG_FromCharPtr("\"%s\""));
  SWIG_Python_SetConstant(d, "FORMAT_BT",SWIG_FromCharPtr("%g"));
  SWIG_Python_SetConstant(d, "FORMAT_DD",SWIG_FromCharPtr("%g"));
  SWIG_Python_SetConstant(d, "FORMAT_BD",SWIG_FromCharPtr("%g"));
  SWIG_Python_SetConstant(d, "FORMAT_4BITS",SWIG_FromCharPtr("%1x"));
  SWIG_Python_SetConstant(d, "FORMAT_D2T",SWIG_FromCharPtr("%s"));
  SWIG_Python_SetConstant(d, "FORMAT_TU",SWIG_FromCharPtr("\"%hn\""));
  SWIG_Python_SetConstant(d, "R_INVALID",SWIG_From_int((int)(R_INVALID)));
  SWIG_Python_SetConstant(d, "R_1_1",SWIG_From_int((int)(R_1_1)));
  SWIG_Python_SetConstant(d, "R_1_2",SWIG_From_int((int)(R_1_2)));
  SWIG_Python_SetConstant(d, "R_1_3",SWIG_From_int((int)(R_1_3)));
  SWIG_Python_SetConstant(d, "R_1_4",SWIG_From_int((int)(R_1_4)));
  SWIG_Python_SetConstant(d, "R_2_0b",SWIG_From_int((int)(R_2_0b)));
  SWIG_Python_SetConstant(d, "R_2_0",SWIG_From_int((int)(R_2_0)));
  SWIG_Python_SetConstant(d, "R_2_10",SWIG_From_int((int)(R_2_10)));
  SWIG_Python_SetConstant(d, "R_2_21",SWIG_From_int((int)(R_2_21)));
  SWIG_Python_SetConstant(d, "R_2_22",SWIG_From_int((int)(R_2_22)));
  SWIG_Python_SetConstant(d, "R_2_4",SWIG_From_int((int)(R_2_4)));
  SWIG_Python_SetConstant(d, "R_2_5",SWIG_From_int((int)(R_2_5)));
  SWIG_Python_SetConstant(d, "R_2_6",SWIG_From_int((int)(R_2_6)));
  SWIG_Python_SetConstant(d, "R_9",SWIG_From_int((int)(R_9)));
  SWIG_Python_SetConstant(d, "R_9c1",SWIG_From_int((int)(R_9c1)));
  SWIG_Python_SetConstant(d, "R_10",SWIG_From_int((int)(R_10)));
  SWIG_Python_SetConstant(d, "R_11b1",SWIG_From_int((int)(R_11b1)));
  SWIG_Python_SetConstant(d, "R_11b2",SWIG_From_int((int)(R_11b2)));
  SWIG_Python_SetConstant(d, "R_11",SWIG_From_int((int)(R_11)));
  SWIG_Python_SetConstant(d, "R_12",SWIG_From_int((int)(R_12)));
  SWIG_Python_SetConstant(d, "R_13b1",SWIG_From_int((int)(R_13b1)));
  SWIG_Python_SetConstant(d, "R_13b2",SWIG_From_int((int)(R_13b2)));
  SWIG_Python_SetConstant(d, "R_13",SWIG_From_int((int)(R_13)));
  SWIG_Python_SetConstant(d, "R_13c3",SWIG_From_int((int)(R_13c3)));
  SWIG_Python_SetConstant(d, "R_14",SWIG_From_int((int)(R_14)));
  SWIG_Python_SetConstant(d, "R_2000b",SWIG_From_int((int)(R_2000b)));
  SWIG_Python_SetConstant(d, "R_2000",SWIG_From_int((int)(R_2000)));
  SWIG_Python_SetConstant(d, "R_2000i",SWIG_From_int((int)(R_2000i)));
  SWIG_Python_SetConstant(d, "R_2002",SWIG_From_int((int)(R_2002)));
  SWIG_Python_SetConstant(d, "R_2004a",SWIG_From_int((int)(R_2004a)));
  SWIG_Python_SetConstant(d, "R_2004b",SWIG_From_int((int)(R_2004b)));
  SWIG_Python_SetConstant(d, "R_2004c",SWIG_From_int((int)(R_2004c)));
  SWIG_Python_SetConstant(d, "R_2004",SWIG_From_int((int)(R_2004)));
  SWIG_Python_SetConstant(d, "R_2007a",SWIG_From_int((int)(R_2007a)));
  SWIG_Python_SetConstant(d, "R_2007b",SWIG_From_int((int)(R_2007b)));
  SWIG_Python_SetConstant(d, "R_2007",SWIG_From_int((int)(R_2007)));
  SWIG_Python_SetConstant(d, "R_2010b",SWIG_From_int((int)(R_2010b)));
  SWIG_Python_SetConstant(d, "R_2010",SWIG_From_int((int)(R_2010)));
  SWIG_Python_SetConstant(d, "R_2013b",SWIG_From_int((int)(R_2013b)));
  SWIG_Python_SetConstant(d, "R_2013",SWIG_From_int((int)(R_2013)));
  SWIG_Python_SetConstant(d, "R_2018b",SWIG_From_int((int)(R_2018b)));
  SWIG_Python_SetConstant(d, "R_2018",SWIG_From_int((int)(R_2018)));
  SWIG_Python_SetConstant(d, "R_2022b",SWIG_From_int((int)(R_2022b)));
  SWIG_Python_SetConstant(d, "R_AFTER",SWIG_From_int((int)(R_AFTER)));
  SWIG_Python_SetConstant(d, "DWG_CLASS_STABLE",SWIG_From_int((int)(DWG_CLASS_STABLE)));
  SWIG_Python_SetConstant(d, "DWG_CLASS_UNSTABLE",SWIG_From_int((int)(DWG_CLASS_UNSTABLE)));
  SWIG_Python_SetConstant(d, "DWG_CLASS_DEBUGGING",SWIG_From_int((int)(DWG_CLASS_DEBUGGING)));
  SWIG_Python_SetConstant(d, "DWG_CLASS_UNHANDLED",SWIG_From_int((int)(DWG_CLASS_UNHANDLED)));
  SWIG_Python_SetConstant(d, "DWG_ENTITY_SECTION",SWIG_From_int((int)(DWG_ENTITY_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_BLOCKS_SECTION",SWIG_From_int((int)(DWG_BLOCKS_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_EXTRA_SECTION",SWIG_From_int((int)(DWG_EXTRA_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_SUPERTYPE_ENTITY",SWIG_From_int((int)(DWG_SUPERTYPE_ENTITY)));
  SWIG_Python_SetConstant(d, "DWG_SUPERTYPE_OBJECT",SWIG_From_int((int)(DWG_SUPERTYPE_OBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UNUSED",SWIG_From_int((int)(DWG_TYPE_UNUSED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TEXT",SWIG_From_int((int)(DWG_TYPE_TEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ATTRIB",SWIG_From_int((int)(DWG_TYPE_ATTRIB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ATTDEF",SWIG_From_int((int)(DWG_TYPE_ATTDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCK",SWIG_From_int((int)(DWG_TYPE_BLOCK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ENDBLK",SWIG_From_int((int)(DWG_TYPE_ENDBLK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SEQEND",SWIG_From_int((int)(DWG_TYPE_SEQEND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_INSERT",SWIG_From_int((int)(DWG_TYPE_INSERT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MINSERT",SWIG_From_int((int)(DWG_TYPE_MINSERT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_2D",SWIG_From_int((int)(DWG_TYPE_VERTEX_2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_3D",SWIG_From_int((int)(DWG_TYPE_VERTEX_3D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_MESH",SWIG_From_int((int)(DWG_TYPE_VERTEX_MESH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_PFACE",SWIG_From_int((int)(DWG_TYPE_VERTEX_PFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_PFACE_FACE",SWIG_From_int((int)(DWG_TYPE_VERTEX_PFACE_FACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLYLINE_2D",SWIG_From_int((int)(DWG_TYPE_POLYLINE_2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLYLINE_3D",SWIG_From_int((int)(DWG_TYPE_POLYLINE_3D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ARC",SWIG_From_int((int)(DWG_TYPE_ARC)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CIRCLE",SWIG_From_int((int)(DWG_TYPE_CIRCLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LINE",SWIG_From_int((int)(DWG_TYPE_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_ORDINATE",SWIG_From_int((int)(DWG_TYPE_DIMENSION_ORDINATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_LINEAR",SWIG_From_int((int)(DWG_TYPE_DIMENSION_LINEAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_ALIGNED",SWIG_From_int((int)(DWG_TYPE_DIMENSION_ALIGNED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_ANG3PT",SWIG_From_int((int)(DWG_TYPE_DIMENSION_ANG3PT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_ANG2LN",SWIG_From_int((int)(DWG_TYPE_DIMENSION_ANG2LN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_RADIUS",SWIG_From_int((int)(DWG_TYPE_DIMENSION_RADIUS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_DIAMETER",SWIG_From_int((int)(DWG_TYPE_DIMENSION_DIAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINT",SWIG_From_int((int)(DWG_TYPE_POINT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE__3DFACE",SWIG_From_int((int)(DWG_TYPE__3DFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLYLINE_PFACE",SWIG_From_int((int)(DWG_TYPE_POLYLINE_PFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLYLINE_MESH",SWIG_From_int((int)(DWG_TYPE_POLYLINE_MESH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SOLID",SWIG_From_int((int)(DWG_TYPE_SOLID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TRACE",SWIG_From_int((int)(DWG_TYPE_TRACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SHAPE",SWIG_From_int((int)(DWG_TYPE_SHAPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VIEWPORT",SWIG_From_int((int)(DWG_TYPE_VIEWPORT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ELLIPSE",SWIG_From_int((int)(DWG_TYPE_ELLIPSE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SPLINE",SWIG_From_int((int)(DWG_TYPE_SPLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_REGION",SWIG_From_int((int)(DWG_TYPE_REGION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE__3DSOLID",SWIG_From_int((int)(DWG_TYPE__3DSOLID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BODY",SWIG_From_int((int)(DWG_TYPE_BODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RAY",SWIG_From_int((int)(DWG_TYPE_RAY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_XLINE",SWIG_From_int((int)(DWG_TYPE_XLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DICTIONARY",SWIG_From_int((int)(DWG_TYPE_DICTIONARY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_OLEFRAME",SWIG_From_int((int)(DWG_TYPE_OLEFRAME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MTEXT",SWIG_From_int((int)(DWG_TYPE_MTEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LEADER",SWIG_From_int((int)(DWG_TYPE_LEADER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TOLERANCE",SWIG_From_int((int)(DWG_TYPE_TOLERANCE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MLINE",SWIG_From_int((int)(DWG_TYPE_MLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCK_CONTROL",SWIG_From_int((int)(DWG_TYPE_BLOCK_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCK_HEADER",SWIG_From_int((int)(DWG_TYPE_BLOCK_HEADER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYER_CONTROL",SWIG_From_int((int)(DWG_TYPE_LAYER_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYER",SWIG_From_int((int)(DWG_TYPE_LAYER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_STYLE_CONTROL",SWIG_From_int((int)(DWG_TYPE_STYLE_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_STYLE",SWIG_From_int((int)(DWG_TYPE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LTYPE_CONTROL",SWIG_From_int((int)(DWG_TYPE_LTYPE_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LTYPE",SWIG_From_int((int)(DWG_TYPE_LTYPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VIEW_CONTROL",SWIG_From_int((int)(DWG_TYPE_VIEW_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VIEW",SWIG_From_int((int)(DWG_TYPE_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UCS_CONTROL",SWIG_From_int((int)(DWG_TYPE_UCS_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UCS",SWIG_From_int((int)(DWG_TYPE_UCS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VPORT_CONTROL",SWIG_From_int((int)(DWG_TYPE_VPORT_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VPORT",SWIG_From_int((int)(DWG_TYPE_VPORT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_APPID_CONTROL",SWIG_From_int((int)(DWG_TYPE_APPID_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_APPID",SWIG_From_int((int)(DWG_TYPE_APPID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMSTYLE_CONTROL",SWIG_From_int((int)(DWG_TYPE_DIMSTYLE_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMSTYLE",SWIG_From_int((int)(DWG_TYPE_DIMSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VX_CONTROL",SWIG_From_int((int)(DWG_TYPE_VX_CONTROL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VX_TABLE_RECORD",SWIG_From_int((int)(DWG_TYPE_VX_TABLE_RECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GROUP",SWIG_From_int((int)(DWG_TYPE_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MLINESTYLE",SWIG_From_int((int)(DWG_TYPE_MLINESTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_OLE2FRAME",SWIG_From_int((int)(DWG_TYPE_OLE2FRAME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DUMMY",SWIG_From_int((int)(DWG_TYPE_DUMMY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LONG_TRANSACTION",SWIG_From_int((int)(DWG_TYPE_LONG_TRANSACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LWPOLYLINE",SWIG_From_int((int)(DWG_TYPE_LWPOLYLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_HATCH",SWIG_From_int((int)(DWG_TYPE_HATCH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_XRECORD",SWIG_From_int((int)(DWG_TYPE_XRECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PLACEHOLDER",SWIG_From_int((int)(DWG_TYPE_PLACEHOLDER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VBA_PROJECT",SWIG_From_int((int)(DWG_TYPE_VBA_PROJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYOUT",SWIG_From_int((int)(DWG_TYPE_LAYOUT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PROXY_ENTITY",SWIG_From_int((int)(DWG_TYPE_PROXY_ENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PROXY_OBJECT",SWIG_From_int((int)(DWG_TYPE_PROXY_OBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDSRECORD",SWIG_From_int((int)(DWG_TYPE_ACDSRECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDSSCHEMA",SWIG_From_int((int)(DWG_TYPE_ACDSSCHEMA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMECOMMANDHISTORY",SWIG_From_int((int)(DWG_TYPE_ACMECOMMANDHISTORY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMESCOPE",SWIG_From_int((int)(DWG_TYPE_ACMESCOPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMESTATEMGR",SWIG_From_int((int)(DWG_TYPE_ACMESTATEMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_BOOLEAN_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_BOOLEAN_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_BOX_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_BOX_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_BREP_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_BREP_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_CHAMFER_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_CHAMFER_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_CONE_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_CONE_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_CYLINDER_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_CYLINDER_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_EXTRUSION_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_EXTRUSION_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_FILLET_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_FILLET_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_HISTORY_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_HISTORY_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_LOFT_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_LOFT_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_PYRAMID_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_PYRAMID_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_REVOLVE_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_REVOLVE_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_SPHERE_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_SPHERE_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_SWEEP_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_SWEEP_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_TORUS_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_TORUS_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_WEDGE_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_WEDGE_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ALDIMOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_ALDIMOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ALIGNMENTPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_ALIGNMENTPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ANGDIMOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_ANGDIMOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ANNOTSCALEOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_ANNOTSCALEOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ARCALIGNEDTEXT",SWIG_From_int((int)(DWG_TYPE_ARCALIGNEDTEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ARC_DIMENSION",SWIG_From_int((int)(DWG_TYPE_ARC_DIMENSION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOC2DCONSTRAINTGROUP",SWIG_From_int((int)(DWG_TYPE_ASSOC2DCONSTRAINTGROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOC3POINTANGULARDIMACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOC3POINTANGULARDIMACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCACTION",SWIG_From_int((int)(DWG_TYPE_ASSOCACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCALIGNEDDIMACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCALIGNEDDIMACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYMODIFYACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYMODIFYACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYMODIFYPARAMETERS",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYMODIFYPARAMETERS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYPATHPARAMETERS",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYPATHPARAMETERS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYPOLARPARAMETERS",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYPOLARPARAMETERS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCARRAYRECTANGULARPARAMETERS",SWIG_From_int((int)(DWG_TYPE_ASSOCARRAYRECTANGULARPARAMETERS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCASMBODYACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCASMBODYACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCBLENDSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCBLENDSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCCOMPOUNDACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCCOMPOUNDACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCDEPENDENCY",SWIG_From_int((int)(DWG_TYPE_ASSOCDEPENDENCY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCDIMDEPENDENCYBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCDIMDEPENDENCYBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCEDGEACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCEDGEACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCEDGECHAMFERACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCEDGECHAMFERACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCEDGEFILLETACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCEDGEFILLETACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCEXTENDSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCEXTENDSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCEXTRUDEDSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCEXTRUDEDSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCFACEACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCFACEACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCFILLETSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCFILLETSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCGEOMDEPENDENCY",SWIG_From_int((int)(DWG_TYPE_ASSOCGEOMDEPENDENCY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCLOFTEDSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCLOFTEDSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCMLEADERACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCMLEADERACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCNETWORK",SWIG_From_int((int)(DWG_TYPE_ASSOCNETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCNETWORKSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCNETWORKSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCOBJECTACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCOBJECTACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCOFFSETSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCOFFSETSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCORDINATEDIMACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCORDINATEDIMACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCOSNAPPOINTREFACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCOSNAPPOINTREFACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCPATCHSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCPATCHSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCPATHACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCPATHACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCPERSSUBENTMANAGER",SWIG_From_int((int)(DWG_TYPE_ASSOCPERSSUBENTMANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCPLANESURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCPLANESURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCPOINTREFACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCPOINTREFACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCRESTOREENTITYSTATEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCRESTOREENTITYSTATEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCREVOLVEDSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCREVOLVEDSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCROTATEDDIMACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCROTATEDDIMACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCSWEPTSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCSWEPTSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCTRIMSURFACEACTIONBODY",SWIG_From_int((int)(DWG_TYPE_ASSOCTRIMSURFACEACTIONBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCVALUEDEPENDENCY",SWIG_From_int((int)(DWG_TYPE_ASSOCVALUEDEPENDENCY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCVARIABLE",SWIG_From_int((int)(DWG_TYPE_ASSOCVARIABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ASSOCVERTEXACTIONPARAM",SWIG_From_int((int)(DWG_TYPE_ASSOCVERTEXACTIONPARAM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BASEPOINTPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_BASEPOINTPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLKREFOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_BLKREFOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKALIGNEDCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKALIGNEDCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKALIGNMENTGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKALIGNMENTGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKALIGNMENTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKALIGNMENTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKANGULARCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKANGULARCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKARRAYACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKARRAYACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKBASEPOINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKBASEPOINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKDIAMETRICCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKDIAMETRICCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKFLIPACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKFLIPACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKFLIPGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKFLIPGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKFLIPPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKFLIPPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKGRIPLOCATIONCOMPONENT",SWIG_From_int((int)(DWG_TYPE_BLOCKGRIPLOCATIONCOMPONENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKHORIZONTALCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKHORIZONTALCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLINEARCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKLINEARCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLINEARGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKLINEARGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLINEARPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKLINEARPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLOOKUPACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKLOOKUPACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLOOKUPGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKLOOKUPGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKLOOKUPPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKLOOKUPPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKMOVEACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKMOVEACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPARAMDEPENDENCYBODY",SWIG_From_int((int)(DWG_TYPE_BLOCKPARAMDEPENDENCYBODY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPOINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKPOINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPOLARGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKPOLARGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPOLARPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKPOLARPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPOLARSTRETCHACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKPOLARSTRETCHACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPROPERTIESTABLE",SWIG_From_int((int)(DWG_TYPE_BLOCKPROPERTIESTABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKPROPERTIESTABLEGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKPROPERTIESTABLEGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKRADIALCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKRADIALCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKREPRESENTATION",SWIG_From_int((int)(DWG_TYPE_BLOCKREPRESENTATION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKROTATEACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKROTATEACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKROTATIONGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKROTATIONGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKROTATIONPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKROTATIONPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKSCALEACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKSCALEACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKSTRETCHACTION",SWIG_From_int((int)(DWG_TYPE_BLOCKSTRETCHACTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKUSERPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKUSERPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKVERTICALCONSTRAINTPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKVERTICALCONSTRAINTPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKVISIBILITYGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKVISIBILITYGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKVISIBILITYPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKVISIBILITYPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKXYGRIP",SWIG_From_int((int)(DWG_TYPE_BLOCKXYGRIP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCKXYPARAMETER",SWIG_From_int((int)(DWG_TYPE_BLOCKXYPARAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CAMERA",SWIG_From_int((int)(DWG_TYPE_CAMERA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CELLSTYLEMAP",SWIG_From_int((int)(DWG_TYPE_CELLSTYLEMAP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CONTEXTDATAMANAGER",SWIG_From_int((int)(DWG_TYPE_CONTEXTDATAMANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CSACDOCUMENTOPTIONS",SWIG_From_int((int)(DWG_TYPE_CSACDOCUMENTOPTIONS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CURVEPATH",SWIG_From_int((int)(DWG_TYPE_CURVEPATH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DATALINK",SWIG_From_int((int)(DWG_TYPE_DATALINK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DATATABLE",SWIG_From_int((int)(DWG_TYPE_DATATABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DBCOLOR",SWIG_From_int((int)(DWG_TYPE_DBCOLOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DETAILVIEWSTYLE",SWIG_From_int((int)(DWG_TYPE_DETAILVIEWSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DGNDEFINITION",SWIG_From_int((int)(DWG_TYPE_DGNDEFINITION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DGNUNDERLAY",SWIG_From_int((int)(DWG_TYPE_DGNUNDERLAY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DICTIONARYVAR",SWIG_From_int((int)(DWG_TYPE_DICTIONARYVAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DICTIONARYWDFLT",SWIG_From_int((int)(DWG_TYPE_DICTIONARYWDFLT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMASSOC",SWIG_From_int((int)(DWG_TYPE_DIMASSOC)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMDIMOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_DMDIMOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DWFDEFINITION",SWIG_From_int((int)(DWG_TYPE_DWFDEFINITION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DWFUNDERLAY",SWIG_From_int((int)(DWG_TYPE_DWFUNDERLAY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DYNAMICBLOCKPROXYNODE",SWIG_From_int((int)(DWG_TYPE_DYNAMICBLOCKPROXYNODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DYNAMICBLOCKPURGEPREVENTER",SWIG_From_int((int)(DWG_TYPE_DYNAMICBLOCKPURGEPREVENTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EVALUATION_GRAPH",SWIG_From_int((int)(DWG_TYPE_EVALUATION_GRAPH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXTRUDEDSURFACE",SWIG_From_int((int)(DWG_TYPE_EXTRUDEDSURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FCFOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_FCFOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FIELD",SWIG_From_int((int)(DWG_TYPE_FIELD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FIELDLIST",SWIG_From_int((int)(DWG_TYPE_FIELDLIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FLIPPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_FLIPPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FLIPACTIONENTITY",SWIG_From_int((int)(DWG_TYPE_FLIPACTIONENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GEODATA",SWIG_From_int((int)(DWG_TYPE_GEODATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GEOMAPIMAGE",SWIG_From_int((int)(DWG_TYPE_GEOMAPIMAGE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GEOPOSITIONMARKER",SWIG_From_int((int)(DWG_TYPE_GEOPOSITIONMARKER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GRADIENT_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_GRADIENT_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GROUND_PLANE_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_GROUND_PLANE_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_HELIX",SWIG_From_int((int)(DWG_TYPE_HELIX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IBL_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_IBL_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IDBUFFER",SWIG_From_int((int)(DWG_TYPE_IDBUFFER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IMAGE",SWIG_From_int((int)(DWG_TYPE_IMAGE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IMAGEDEF",SWIG_From_int((int)(DWG_TYPE_IMAGEDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IMAGEDEF_REACTOR",SWIG_From_int((int)(DWG_TYPE_IMAGEDEF_REACTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IMAGE_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_IMAGE_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_INDEX",SWIG_From_int((int)(DWG_TYPE_INDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LARGE_RADIAL_DIMENSION",SWIG_From_int((int)(DWG_TYPE_LARGE_RADIAL_DIMENSION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYERFILTER",SWIG_From_int((int)(DWG_TYPE_LAYERFILTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYER_INDEX",SWIG_From_int((int)(DWG_TYPE_LAYER_INDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LAYOUTPRINTCONFIG",SWIG_From_int((int)(DWG_TYPE_LAYOUTPRINTCONFIG)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LEADEROBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_LEADEROBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LIGHT",SWIG_From_int((int)(DWG_TYPE_LIGHT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LIGHTLIST",SWIG_From_int((int)(DWG_TYPE_LIGHTLIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LINEARPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_LINEARPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LOFTEDSURFACE",SWIG_From_int((int)(DWG_TYPE_LOFTEDSURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MATERIAL",SWIG_From_int((int)(DWG_TYPE_MATERIAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MENTALRAYRENDERSETTINGS",SWIG_From_int((int)(DWG_TYPE_MENTALRAYRENDERSETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MESH",SWIG_From_int((int)(DWG_TYPE_MESH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MLEADEROBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_MLEADEROBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MLEADERSTYLE",SWIG_From_int((int)(DWG_TYPE_MLEADERSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MOVEACTIONENTITY",SWIG_From_int((int)(DWG_TYPE_MOVEACTIONENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MOTIONPATH",SWIG_From_int((int)(DWG_TYPE_MOTIONPATH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MPOLYGON",SWIG_From_int((int)(DWG_TYPE_MPOLYGON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MTEXTATTRIBUTEOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_MTEXTATTRIBUTEOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MTEXTOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_MTEXTOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MULTILEADER",SWIG_From_int((int)(DWG_TYPE_MULTILEADER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NAVISWORKSMODEL",SWIG_From_int((int)(DWG_TYPE_NAVISWORKSMODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NAVISWORKSMODELDEF",SWIG_From_int((int)(DWG_TYPE_NAVISWORKSMODELDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NPOCOLLECTION",SWIG_From_int((int)(DWG_TYPE_NPOCOLLECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NURBSURFACE",SWIG_From_int((int)(DWG_TYPE_NURBSURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_OBJECT_PTR",SWIG_From_int((int)(DWG_TYPE_OBJECT_PTR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ORDDIMOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_ORDDIMOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PARTIAL_VIEWING_INDEX",SWIG_From_int((int)(DWG_TYPE_PARTIAL_VIEWING_INDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PDFDEFINITION",SWIG_From_int((int)(DWG_TYPE_PDFDEFINITION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PDFUNDERLAY",SWIG_From_int((int)(DWG_TYPE_PDFUNDERLAY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PERSUBENTMGR",SWIG_From_int((int)(DWG_TYPE_PERSUBENTMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PLANESURFACE",SWIG_From_int((int)(DWG_TYPE_PLANESURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PLOTSETTINGS",SWIG_From_int((int)(DWG_TYPE_PLOTSETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUD",SWIG_From_int((int)(DWG_TYPE_POINTCLOUD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDCOLORMAP",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDCOLORMAP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDDEF",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDDEFEX",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDDEFEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDDEF_REACTOR",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDDEF_REACTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDDEF_REACTOR_EX",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDDEF_REACTOR_EX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTCLOUDEX",SWIG_From_int((int)(DWG_TYPE_POINTCLOUDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_POINTPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINTPATH",SWIG_From_int((int)(DWG_TYPE_POINTPATH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLARGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_POLARGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RADIMLGOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_RADIMLGOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RADIMOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_RADIMOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RAPIDRTRENDERSETTINGS",SWIG_From_int((int)(DWG_TYPE_RAPIDRTRENDERSETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RASTERVARIABLES",SWIG_From_int((int)(DWG_TYPE_RASTERVARIABLES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RENDERENTRY",SWIG_From_int((int)(DWG_TYPE_RENDERENTRY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RENDERENVIRONMENT",SWIG_From_int((int)(DWG_TYPE_RENDERENVIRONMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RENDERGLOBAL",SWIG_From_int((int)(DWG_TYPE_RENDERGLOBAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RENDERSETTINGS",SWIG_From_int((int)(DWG_TYPE_RENDERSETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_REVOLVEDSURFACE",SWIG_From_int((int)(DWG_TYPE_REVOLVEDSURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ROTATIONPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_ROTATIONPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ROTATEACTIONENTITY",SWIG_From_int((int)(DWG_TYPE_ROTATEACTIONENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_RTEXT",SWIG_From_int((int)(DWG_TYPE_RTEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SCALE",SWIG_From_int((int)(DWG_TYPE_SCALE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SCALEACTIONENTITY",SWIG_From_int((int)(DWG_TYPE_SCALEACTIONENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SECTIONOBJECT",SWIG_From_int((int)(DWG_TYPE_SECTIONOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SECTIONVIEWSTYLE",SWIG_From_int((int)(DWG_TYPE_SECTIONVIEWSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SECTION_MANAGER",SWIG_From_int((int)(DWG_TYPE_SECTION_MANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SECTION_SETTINGS",SWIG_From_int((int)(DWG_TYPE_SECTION_SETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SKYLIGHT_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_SKYLIGHT_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SOLID_BACKGROUND",SWIG_From_int((int)(DWG_TYPE_SOLID_BACKGROUND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SORTENTSTABLE",SWIG_From_int((int)(DWG_TYPE_SORTENTSTABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SPATIAL_FILTER",SWIG_From_int((int)(DWG_TYPE_SPATIAL_FILTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SPATIAL_INDEX",SWIG_From_int((int)(DWG_TYPE_SPATIAL_INDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_STRETCHACTIONENTITY",SWIG_From_int((int)(DWG_TYPE_STRETCHACTIONENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SUN",SWIG_From_int((int)(DWG_TYPE_SUN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SUNSTUDY",SWIG_From_int((int)(DWG_TYPE_SUNSTUDY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SWEPTSURFACE",SWIG_From_int((int)(DWG_TYPE_SWEPTSURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TABLE",SWIG_From_int((int)(DWG_TYPE_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TABLECONTENT",SWIG_From_int((int)(DWG_TYPE_TABLECONTENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TABLEGEOMETRY",SWIG_From_int((int)(DWG_TYPE_TABLEGEOMETRY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TABLESTYLE",SWIG_From_int((int)(DWG_TYPE_TABLESTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TEXTOBJECTCONTEXTDATA",SWIG_From_int((int)(DWG_TYPE_TEXTOBJECTCONTEXTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TVDEVICEPROPERTIES",SWIG_From_int((int)(DWG_TYPE_TVDEVICEPROPERTIES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VISIBILITYGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_VISIBILITYGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VISIBILITYPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_VISIBILITYPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VISUALSTYLE",SWIG_From_int((int)(DWG_TYPE_VISUALSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_WIPEOUT",SWIG_From_int((int)(DWG_TYPE_WIPEOUT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_WIPEOUTVARIABLES",SWIG_From_int((int)(DWG_TYPE_WIPEOUTVARIABLES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_XREFPANELOBJECT",SWIG_From_int((int)(DWG_TYPE_XREFPANELOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_XYPARAMETERENTITY",SWIG_From_int((int)(DWG_TYPE_XYPARAMETERENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BREAKDATA",SWIG_From_int((int)(DWG_TYPE_BREAKDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BREAKPOINTREF",SWIG_From_int((int)(DWG_TYPE_BREAKPOINTREF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FLIPGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_FLIPGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LINEARGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_LINEARGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ROTATIONGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_ROTATIONGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_XYGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_XYGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE__3DLINE",SWIG_From_int((int)(DWG_TYPE__3DLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_REPEAT",SWIG_From_int((int)(DWG_TYPE_REPEAT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ENDREP",SWIG_From_int((int)(DWG_TYPE_ENDREP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_JUMP",SWIG_From_int((int)(DWG_TYPE_JUMP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LOAD",SWIG_From_int((int)(DWG_TYPE_LOAD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ABSHDRAWINGSETTINGS",SWIG_From_int((int)(DWG_TYPE_ABSHDRAWINGSETTINGS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAECUSTOBJ",SWIG_From_int((int)(DWG_TYPE_ACAECUSTOBJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAEEEMGROBJ",SWIG_From_int((int)(DWG_TYPE_ACAEEEMGROBJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMCOMP",SWIG_From_int((int)(DWG_TYPE_ACAMCOMP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMCOMPDEF",SWIG_From_int((int)(DWG_TYPE_ACAMCOMPDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMCOMPDEFMGR",SWIG_From_int((int)(DWG_TYPE_ACAMCOMPDEFMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMCONTEXTMODELER",SWIG_From_int((int)(DWG_TYPE_ACAMCONTEXTMODELER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGDIMSTD",SWIG_From_int((int)(DWG_TYPE_ACAMGDIMSTD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGFILTERDAT",SWIG_From_int((int)(DWG_TYPE_ACAMGFILTERDAT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGHOLECHARTSTDCSN",SWIG_From_int((int)(DWG_TYPE_ACAMGHOLECHARTSTDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGHOLECHARTSTDDIN",SWIG_From_int((int)(DWG_TYPE_ACAMGHOLECHARTSTDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGHOLECHARTSTDISO",SWIG_From_int((int)(DWG_TYPE_ACAMGHOLECHARTSTDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGLAYSTD",SWIG_From_int((int)(DWG_TYPE_ACAMGLAYSTD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGRCOMPDEF",SWIG_From_int((int)(DWG_TYPE_ACAMGRCOMPDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGRCOMPDEFSET",SWIG_From_int((int)(DWG_TYPE_ACAMGRCOMPDEFSET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMGTITLESTD",SWIG_From_int((int)(DWG_TYPE_ACAMGTITLESTD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMMVDBACKUPOBJECT",SWIG_From_int((int)(DWG_TYPE_ACAMMVDBACKUPOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMPROJECT",SWIG_From_int((int)(DWG_TYPE_ACAMPROJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMSHAFTCOMPDEF",SWIG_From_int((int)(DWG_TYPE_ACAMSHAFTCOMPDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMSTDPCOMPDEF",SWIG_From_int((int)(DWG_TYPE_ACAMSTDPCOMPDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACAMWBLOCKTEMPENTS",SWIG_From_int((int)(DWG_TYPE_ACAMWBLOCKTEMPENTS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACARRAYJIGENTITY",SWIG_From_int((int)(DWG_TYPE_ACARRAYJIGENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACCMCONTEXT",SWIG_From_int((int)(DWG_TYPE_ACCMCONTEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBCIRCARCRES",SWIG_From_int((int)(DWG_TYPE_ACDBCIRCARCRES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBDIMENSIONRES",SWIG_From_int((int)(DWG_TYPE_ACDBDIMENSIONRES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBENTITYCACHE",SWIG_From_int((int)(DWG_TYPE_ACDBENTITYCACHE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBLINERES",SWIG_From_int((int)(DWG_TYPE_ACDBLINERES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBSTDPARTRES_ARC",SWIG_From_int((int)(DWG_TYPE_ACDBSTDPARTRES_ARC)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDBSTDPARTRES_LINE",SWIG_From_int((int)(DWG_TYPE_ACDBSTDPARTRES_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDB_HATCHSCALECONTEXTDATA_CLASS",SWIG_From_int((int)(DWG_TYPE_ACDB_HATCHSCALECONTEXTDATA_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDB_HATCHVIEWCONTEXTDATA_CLASS",SWIG_From_int((int)(DWG_TYPE_ACDB_HATCHVIEWCONTEXTDATA_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACDB_PROXY_ENTITY_DATA",SWIG_From_int((int)(DWG_TYPE_ACDB_PROXY_ENTITY_DATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACGREFACADMASTER",SWIG_From_int((int)(DWG_TYPE_ACGREFACADMASTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACGREFMASTER",SWIG_From_int((int)(DWG_TYPE_ACGREFMASTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACIMINTSYSVAR",SWIG_From_int((int)(DWG_TYPE_ACIMINTSYSVAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACIMREALSYSVAR",SWIG_From_int((int)(DWG_TYPE_ACIMREALSYSVAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACIMSTRSYSVAR",SWIG_From_int((int)(DWG_TYPE_ACIMSTRSYSVAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACIMSYSVARMAN",SWIG_From_int((int)(DWG_TYPE_ACIMSYSVARMAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMANOOTATIONVIEWSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMANOOTATIONVIEWSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMANOOTATIONVIEWSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMANOOTATIONVIEWSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMANOOTATIONVIEWSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMANOOTATIONVIEWSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMANOOTATIONVIEWSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMANOOTATIONVIEWSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMAPLEGENDDBOBJECT",SWIG_From_int((int)(DWG_TYPE_ACMAPLEGENDDBOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMAPLEGENDITEMDBOBJECT",SWIG_From_int((int)(DWG_TYPE_ACMAPLEGENDITEMDBOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMAPMAPVIEWPORTDBOBJECT",SWIG_From_int((int)(DWG_TYPE_ACMAPMAPVIEWPORTDBOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMAPPRINTLAYOUTELEMENTDBOBJECTCONTAINER",SWIG_From_int((int)(DWG_TYPE_ACMAPPRINTLAYOUTELEMENTDBOBJECTCONTAINER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBALLOON",SWIG_From_int((int)(DWG_TYPE_ACMBALLOON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOM",SWIG_From_int((int)(DWG_TYPE_ACMBOM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMROW",SWIG_From_int((int)(DWG_TYPE_ACMBOMROW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMROWSTRUCT",SWIG_From_int((int)(DWG_TYPE_ACMBOMROWSTRUCT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMBOMSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMBOMSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMBOMSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMBOMSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMBOMSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMCENTERLINESTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMCENTERLINESTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMCENTERLINESTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMCENTERLINESTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMCENTERLINESTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMCENTERLINESTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMCENTERLINESTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMCENTERLINESTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATADICTIONARY",SWIG_From_int((int)(DWG_TYPE_ACMDATADICTIONARY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATAENTRY",SWIG_From_int((int)(DWG_TYPE_ACMDATAENTRY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATAENTRYBLOCK",SWIG_From_int((int)(DWG_TYPE_ACMDATAENTRYBLOCK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMID",SWIG_From_int((int)(DWG_TYPE_ACMDATUMID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMDATUMSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMDATUMSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMDATUMSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMDATUMSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDATUMSTANDARDISO2012",SWIG_From_int((int)(DWG_TYPE_ACMDATUMSTANDARDISO2012)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDETAILSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMDETAILSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDETAILSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMDETAILSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDETAILSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMDETAILSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDETAILSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMDETAILSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDETAILTANDARDCUSTOM",SWIG_From_int((int)(DWG_TYPE_ACMDETAILTANDARDCUSTOM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMDIMBREAKPERSREACTOR",SWIG_From_int((int)(DWG_TYPE_ACMDIMBREAKPERSREACTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMEDRAWINGMAN",SWIG_From_int((int)(DWG_TYPE_ACMEDRAWINGMAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMEVIEW",SWIG_From_int((int)(DWG_TYPE_ACMEVIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACME_DATABASE",SWIG_From_int((int)(DWG_TYPE_ACME_DATABASE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACME_DOCUMENT",SWIG_From_int((int)(DWG_TYPE_ACME_DOCUMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFRAME",SWIG_From_int((int)(DWG_TYPE_ACMFCFRAME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDISO2004",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDISO2004)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMFCFSTANDARDISO2012",SWIG_From_int((int)(DWG_TYPE_ACMFCFSTANDARDISO2012)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDISO2004",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDISO2004)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMIDSTANDARDISO2012",SWIG_From_int((int)(DWG_TYPE_ACMIDSTANDARDISO2012)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMNOTESTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMNOTESTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMNOTESTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMNOTESTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMNOTESTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMNOTESTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMNOTESTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMNOTESTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMPARTLIST",SWIG_From_int((int)(DWG_TYPE_ACMPARTLIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMPICKOBJ",SWIG_From_int((int)(DWG_TYPE_ACMPICKOBJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDCSN2002",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDCSN2002)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDCUSTOM",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDCUSTOM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSECTIONSTANDARDISO2001",SWIG_From_int((int)(DWG_TYPE_ACMSECTIONSTANDARDISO2001)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMSURFSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMSURFSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMSURFSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMSURFSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSTANDARDISO2002",SWIG_From_int((int)(DWG_TYPE_ACMSURFSTANDARDISO2002)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMSURFSYM",SWIG_From_int((int)(DWG_TYPE_ACMSURFSYM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTAPERSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMTAPERSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTAPERSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMTAPERSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTAPERSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMTAPERSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTAPERSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMTAPERSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTHREADLINESTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMTHREADLINESTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTHREADLINESTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMTHREADLINESTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTHREADLINESTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMTHREADLINESTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMTHREADLINESTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMTHREADLINESTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMWELDSTANDARDANSI",SWIG_From_int((int)(DWG_TYPE_ACMWELDSTANDARDANSI)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMWELDSTANDARDCSN",SWIG_From_int((int)(DWG_TYPE_ACMWELDSTANDARDCSN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMWELDSTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_ACMWELDSTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMWELDSTANDARDISO",SWIG_From_int((int)(DWG_TYPE_ACMWELDSTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACMWELDSYM",SWIG_From_int((int)(DWG_TYPE_ACMWELDSYM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACRFATTGENMGR",SWIG_From_int((int)(DWG_TYPE_ACRFATTGENMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACRFINSADJ",SWIG_From_int((int)(DWG_TYPE_ACRFINSADJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACRFINSADJUSTERMGR",SWIG_From_int((int)(DWG_TYPE_ACRFINSADJUSTERMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACRFMCADAPIATTHOLDER",SWIG_From_int((int)(DWG_TYPE_ACRFMCADAPIATTHOLDER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACRFOBJATTMGR",SWIG_From_int((int)(DWG_TYPE_ACRFOBJATTMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ACSH_SUBENT_MATERIAL_CLASS",SWIG_From_int((int)(DWG_TYPE_ACSH_SUBENT_MATERIAL_CLASS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_2D_XREF_MGR",SWIG_From_int((int)(DWG_TYPE_AC_AM_2D_XREF_MGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_BASIC_VIEW",SWIG_From_int((int)(DWG_TYPE_AC_AM_BASIC_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_BASIC_VIEW_DEF",SWIG_From_int((int)(DWG_TYPE_AC_AM_BASIC_VIEW_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_COMPLEX_HIDE_SITUATION",SWIG_From_int((int)(DWG_TYPE_AC_AM_COMPLEX_HIDE_SITUATION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_COMP_VIEW_DEF",SWIG_From_int((int)(DWG_TYPE_AC_AM_COMP_VIEW_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_COMP_VIEW_INST",SWIG_From_int((int)(DWG_TYPE_AC_AM_COMP_VIEW_INST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_DIRTY_NODES",SWIG_From_int((int)(DWG_TYPE_AC_AM_DIRTY_NODES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_HIDE_SITUATION",SWIG_From_int((int)(DWG_TYPE_AC_AM_HIDE_SITUATION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_MAPPER_CACHE",SWIG_From_int((int)(DWG_TYPE_AC_AM_MAPPER_CACHE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_MASTER_VIEW_DEF",SWIG_From_int((int)(DWG_TYPE_AC_AM_MASTER_VIEW_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_MVD_DEP_MGR",SWIG_From_int((int)(DWG_TYPE_AC_AM_MVD_DEP_MGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_OVERRIDE_FILTER",SWIG_From_int((int)(DWG_TYPE_AC_AM_OVERRIDE_FILTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_PROPS_OVERRIDE",SWIG_From_int((int)(DWG_TYPE_AC_AM_PROPS_OVERRIDE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_SHAFT_HIDE_SITUATION",SWIG_From_int((int)(DWG_TYPE_AC_AM_SHAFT_HIDE_SITUATION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_STDP_VIEW_DEF",SWIG_From_int((int)(DWG_TYPE_AC_AM_STDP_VIEW_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AC_AM_TRANSFORM_GHOST",SWIG_From_int((int)(DWG_TYPE_AC_AM_TRANSFORM_GHOST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ADAPPL",SWIG_From_int((int)(DWG_TYPE_ADAPPL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ALIGNMENT_DESIGN_CHECK_SET",SWIG_From_int((int)(DWG_TYPE_AECC_ALIGNMENT_DESIGN_CHECK_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ALIGNMENT_LABEL_SET",SWIG_From_int((int)(DWG_TYPE_AECC_ALIGNMENT_LABEL_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ALIGNMENT_LABEL_SET_EXT",SWIG_From_int((int)(DWG_TYPE_AECC_ALIGNMENT_LABEL_SET_EXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ALIGNMENT_PARCEL_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_ALIGNMENT_PARCEL_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ALIGNMENT_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_ALIGNMENT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_APPURTENANCE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_APPURTENANCE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ASSEMBLY_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_ASSEMBLY_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_BUILDING_SITE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_BUILDING_SITE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_CANT_DIAGRAM_VIEW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_CANT_DIAGRAM_VIEW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_CATCHMENT_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_CATCHMENT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_CLASS_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_CLASS_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_CONTOURVIEW",SWIG_From_int((int)(DWG_TYPE_AECC_CONTOURVIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_CORRIDOR_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_CORRIDOR_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CANT_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CANT_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CURVE_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_CURVE_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_DESIGNSPEED_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_DESIGNSPEED_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_GEOMPT_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_GEOMPT_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_INDEXED_PI_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_INDEXED_PI_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_MINOR_STATION_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_MINOR_STATION_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_PI_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_PI_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_SPIRAL_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_SPIRAL_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STAEQU_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STAEQU_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STATION_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STATION_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STATION_OFFSET_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_STATION_OFFSET_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_SUPERELEVATION_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_SUPERELEVATION_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_TANGENT_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_TANGENT_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ALIGNMENT_VERTICAL_GEOMPT_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ALIGNMENT_VERTICAL_GEOMPT_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_APPURTENANCE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_APPURTENANCE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_APPURTENANCE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_APPURTENANCE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_APPURTENANCE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_APPURTENANCE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_APPURTENANCE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_APPURTENANCE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_ASSEMBLY",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_ASSEMBLY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE_PROFILE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_CORRIDOR_FEATURE_LINE_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_PROFILE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_AUTO_FEATURE_LINE_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_BUILDINGSITE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_BUILDINGSITE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_BUILDINGUTIL_CONNECTOR",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_BUILDINGUTIL_CONNECTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CANT_DIAGRAM_VIEW",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CANT_DIAGRAM_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CATCHMENT_AREA",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CATCHMENT_AREA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CATCHMENT_AREA_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CATCHMENT_AREA_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CORRIDOR",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CORRIDOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CROSSING_PIPE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CROSSING_PIPE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CROSSING_PRESSURE_PIPE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CROSSING_PRESSURE_PIPE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_CSVSTATIONSLIDER",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_CSVSTATIONSLIDER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FACE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE_LINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_PROFILE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FEATURE_LINE_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FITTING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FITTING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FITTING_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FITTING_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FITTING_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FITTING_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FITTING_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FITTING_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_FLOW_SEGMENT_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_FLOW_SEGMENT_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GENERAL_SEGMENT_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GENERAL_SEGMENT_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRADING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRADING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRAPH",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRAPH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRAPHPROFILE_NETWORKPART",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRAPHPROFILE_NETWORKPART)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRAPHPROFILE_PRESSUREPART",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRAPHPROFILE_PRESSUREPART)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRID_SURFACE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRID_SURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_GRID_SURFACE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_GRID_SURFACE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_HORGEOMETRY_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_HORGEOMETRY_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_HYDRO_REGION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_HYDRO_REGION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_INTERFERENCE_CHECK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_INTERFERENCE_CHECK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_INTERFERENCE_PART",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_INTERFERENCE_PART)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_INTERFERENCE_PART_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_INTERFERENCE_PART_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_INTERSECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_INTERSECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_INTERSECTION_LOCATION_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_INTERSECTION_LOCATION_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_LEGEND_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_LEGEND_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_LINE_BETWEEN_POINTS_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_LINE_BETWEEN_POINTS_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_LOTLINE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_LOTLINE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_MASSHAULLINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_MASSHAULLINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_MASS_HAUL_VIEW",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_MASS_HAUL_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_MATCHLINE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_MATCHLINE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_MATCH_LINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_MATCH_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_MATERIAL_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_MATERIAL_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_NETWORK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_NETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_NOTE_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_NOTE_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_OFFSET_ELEV_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_OFFSET_ELEV_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_BOUNDARY",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_BOUNDARY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_FACE_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_FACE_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_SEGMENT_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PARCEL_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PARCEL_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPENETWORK_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPENETWORK_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE_SECTION_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE_SECTION_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PIPE_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PIPE_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_POINT_ENT",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_POINT_ENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_POINT_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_POINT_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_POINT_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_POINT_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSUREPIPENETWORK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSUREPIPENETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PART_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PART_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_SECTION_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PRESSURE_PIPE_SECTION_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILEDATA_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILEDATA_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILE_PROJECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILE_PROJECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILE_PROJECTION_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILE_PROJECTION_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILE_VIEW",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILE_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_PROFILE_VIEW_DEPTH_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_PROFILE_VIEW_DEPTH_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_QUANTITY_TAKEOFF_AGGREGATE_EARTHWORK_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_QUANTITY_TAKEOFF_AGGREGATE_EARTHWORK_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_RIGHT_OF_WAY",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_RIGHT_OF_WAY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SAMPLELINE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SAMPLELINE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SAMPLE_LINE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SAMPLE_LINE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SAMPLE_LINE_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SAMPLE_LINE_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTIONALDATA_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTIONALDATA_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTIONDATA_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTIONDATA_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTIONSEGMENT_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTIONSEGMENT_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_CORRIDOR",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_CORRIDOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_CORRIDOR_POINT_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_CORRIDOR_POINT_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_GRADEBREAK_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_GRADEBREAK_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_MINOR_OFFSET_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_MINOR_OFFSET_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_OFFSET_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_OFFSET_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_PIPENETWORK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_PIPENETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_PRESSUREPIPENETWORK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_PRESSUREPIPENETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_PROJECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_PROJECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_PROJECTION_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_PROJECTION_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_SEGMENT_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_SEGMENT_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_VIEW",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_VIEW_DEPTH_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_VIEW_DEPTH_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SECTION_VIEW_QUANTITY_TAKEOFF_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SECTION_VIEW_QUANTITY_TAKEOFF_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SHEET",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SHEET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SPANNING_PIPE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SPANNING_PIPE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SPANNING_PIPE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SPANNING_PIPE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STATION_ELEV_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STATION_ELEV_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STRUCTURE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STRUCTURE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STRUCTURE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STRUCTURE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STRUCTURE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STRUCTURE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STRUCTURE_PROFILE_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STRUCTURE_PROFILE_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_STRUCTURE_SECTION_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_STRUCTURE_SECTION_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SUBASSEMBLY",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SUBASSEMBLY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SUPERELEVATION_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SUPERELEVATION_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SUPERELEVATION_DIAGRAM_VIEW",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SUPERELEVATION_DIAGRAM_VIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SURFACE_CONTOUR_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SURFACE_CONTOUR_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SURFACE_ELEVATION_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SURFACE_ELEVATION_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SURFACE_SLOPE_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SURFACE_SLOPE_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SURVEY_FIGURE_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SURVEY_FIGURE_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVFIGURE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVFIGURE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVFIGURE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVFIGURE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVFIGURE_PROFILE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVFIGURE_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVFIGURE_SECTION",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVFIGURE_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVFIGURE_SEGMENT_LABEL",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVFIGURE_SEGMENT_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_SVNETWORK",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_SVNETWORK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_TANGENT_INTERSECTION_TABLE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_TANGENT_INTERSECTION_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_TIN_SURFACE",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_TIN_SURFACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_TIN_SURFACE_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_TIN_SURFACE_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_CRESTCURVE_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_CRESTCURVE_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_CSV",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_CSV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_HAGEOMPT_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_HAGEOMPT_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_LINE_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_LINE_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_MINOR_STATION_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_MINOR_STATION_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_PVI_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_PVI_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_SAGCURVE_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_SAGCURVE_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VALIGNMENT_STATION_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VALIGNMENT_STATION_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VERTICALGEOMETRY_BAND_LABEL_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VERTICALGEOMETRY_BAND_LABEL_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VIEWFRAME_LABELING",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VIEWFRAME_LABELING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_DISP_REP_VIEW_FRAME",SWIG_From_int((int)(DWG_TYPE_AECC_DISP_REP_VIEW_FRAME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_FEATURELINE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_FEATURELINE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_FEATURE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_FEATURE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_FITTING_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_FITTING_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_FORMAT_MANAGER_OBJECT",SWIG_From_int((int)(DWG_TYPE_AECC_FORMAT_MANAGER_OBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_GRADEVIEW",SWIG_From_int((int)(DWG_TYPE_AECC_GRADEVIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_GRADING_CRITERIA",SWIG_From_int((int)(DWG_TYPE_AECC_GRADING_CRITERIA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_GRADING_CRITERIA_SET",SWIG_From_int((int)(DWG_TYPE_AECC_GRADING_CRITERIA_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_GRADING_GROUP",SWIG_From_int((int)(DWG_TYPE_AECC_GRADING_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_GRADING_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_GRADING_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_IMPORT_STORM_SEWER_DEFAULTS",SWIG_From_int((int)(DWG_TYPE_AECC_IMPORT_STORM_SEWER_DEFAULTS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_INTERFERENCE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_INTERFERENCE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_INTERSECTION_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_INTERSECTION_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_COLLECTOR_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_COLLECTOR_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_RADIAL_LINE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_RADIAL_LINE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_TEXT_ITERATOR_CURVE_OR_SPIRAL_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_TEXT_ITERATOR_CURVE_OR_SPIRAL_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_TEXT_ITERATOR_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_TEXT_ITERATOR_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_TEXT_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_TEXT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LABEL_VECTOR_ARROW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LABEL_VECTOR_ARROW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_LEGEND_TABLE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_LEGEND_TABLE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_MASS_HAUL_LINE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_MASS_HAUL_LINE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_MASS_HAUL_VIEW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_MASS_HAUL_VIEW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_MATCHLINE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_MATCHLINE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_MATERIAL_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_MATERIAL_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_NETWORK_PART_CATALOG_DEF_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_NETWORK_PART_CATALOG_DEF_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_NETWORK_PART_FAMILY_ITEM",SWIG_From_int((int)(DWG_TYPE_AECC_NETWORK_PART_FAMILY_ITEM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_NETWORK_PART_LIST",SWIG_From_int((int)(DWG_TYPE_AECC_NETWORK_PART_LIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_NETWORK_RULE",SWIG_From_int((int)(DWG_TYPE_AECC_NETWORK_RULE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PARCEL_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_PARCEL_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PARCEL_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PARCEL_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PART_SIZE_FILTER",SWIG_From_int((int)(DWG_TYPE_AECC_PART_SIZE_FILTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PIPE_RULES",SWIG_From_int((int)(DWG_TYPE_AECC_PIPE_RULES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PIPE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PIPE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PIPE_STYLE_EXTENSION",SWIG_From_int((int)(DWG_TYPE_AECC_PIPE_STYLE_EXTENSION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_POINTCLOUD_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_POINTCLOUD_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_POINTVIEW",SWIG_From_int((int)(DWG_TYPE_AECC_POINTVIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_POINT_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_POINT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PRESSURE_PART_LIST",SWIG_From_int((int)(DWG_TYPE_AECC_PRESSURE_PART_LIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PRESSURE_PIPE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PRESSURE_PIPE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILESECTIONENTITY_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILESECTIONENTITY_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_DESIGN_CHECK_SET",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_DESIGN_CHECK_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_LABEL_SET",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_LABEL_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_BAND_STYLE_SET",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_BAND_STYLE_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_DATA_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_DATA_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_HORIZONTAL_GEOMETRY_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_HORIZONTAL_GEOMETRY_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_PIPE_NETWORK_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_PIPE_NETWORK_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_SECTIONAL_DATA_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_SECTIONAL_DATA_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_SUPERELEVATION_DIAGRAM_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_SUPERELEVATION_DIAGRAM_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_PROFILE_VIEW_VERTICAL_GEOMETRY_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_PROFILE_VIEW_VERTICAL_GEOMETRY_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_QUANTITY_TAKEOFF_CRITERIA",SWIG_From_int((int)(DWG_TYPE_AECC_QUANTITY_TAKEOFF_CRITERIA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ROADWAYLINK_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_ROADWAYLINK_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ROADWAYMARKER_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_ROADWAYMARKER_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ROADWAYSHAPE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_ROADWAYSHAPE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ROADWAY_STYLE_SET",SWIG_From_int((int)(DWG_TYPE_AECC_ROADWAY_STYLE_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_ROOT_SETTINGS_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_ROOT_SETTINGS_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SAMPLE_LINE_GROUP_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SAMPLE_LINE_GROUP_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SAMPLE_LINE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SAMPLE_LINE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_LABEL_SET",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_LABEL_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_VIEW_BAND_STYLE_SET",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_VIEW_BAND_STYLE_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_VIEW_DATA_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_VIEW_DATA_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_VIEW_ROAD_SURFACE_BAND_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_VIEW_ROAD_SURFACE_BAND_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SECTION_VIEW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SECTION_VIEW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SETTINGS_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_SETTINGS_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SHEET_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SHEET_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SLOPE_PATTERN_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SLOPE_PATTERN_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_STATION_FORMAT_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_STATION_FORMAT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_STRUCTURE_RULES",SWIG_From_int((int)(DWG_TYPE_AECC_STRUCTURE_RULES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_STUCTURE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_STUCTURE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SUPERELEVATION_DIAGRAM_VIEW_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SUPERELEVATION_DIAGRAM_VIEW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SURFACE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SURFACE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SVFIGURE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SVFIGURE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_SVNETWORK_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_SVNETWORK_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_TABLE_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_TABLE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_TAG_MANAGER",SWIG_From_int((int)(DWG_TYPE_AECC_TAG_MANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_TREE_NODE",SWIG_From_int((int)(DWG_TYPE_AECC_TREE_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_USER_DEFINED_ATTRIBUTE_CLASSIFICATION",SWIG_From_int((int)(DWG_TYPE_AECC_USER_DEFINED_ATTRIBUTE_CLASSIFICATION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_VALIGNMENT_STYLE_EXTENSION",SWIG_From_int((int)(DWG_TYPE_AECC_VALIGNMENT_STYLE_EXTENSION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECC_VIEW_FRAME_STYLE",SWIG_From_int((int)(DWG_TYPE_AECC_VIEW_FRAME_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_PROPS_MEMBER",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_PROPS_MEMBER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_PROPS_MEMBER_LOGICAL",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_PROPS_MEMBER_LOGICAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_PROPS_MEMBER_PLAN",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_PROPS_MEMBER_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_PROPS_MEMBER_PLAN_SKETCH",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_PROPS_MEMBER_PLAN_SKETCH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_PROPS_MEMBER_PROJECTED",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_PROPS_MEMBER_PROJECTED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_ELEVATION_DESIGN",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_ELEVATION_DESIGN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_ELEVATION_DETAIL",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_ELEVATION_DETAIL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_LOGICAL",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_LOGICAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_MODEL_DESIGN",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_MODEL_DESIGN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_MODEL_DETAIL",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_MODEL_DETAIL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_DESIGN",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_DESIGN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_DETAIL",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_DETAIL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_SKETCH",SWIG_From_int((int)(DWG_TYPE_AECS_DISP_REP_MEMBER_PLAN_SKETCH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_MEMBER_NODE_SHAPE",SWIG_From_int((int)(DWG_TYPE_AECS_MEMBER_NODE_SHAPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AECS_MEMBER_STYLE",SWIG_From_int((int)(DWG_TYPE_AECS_MEMBER_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_2DSECTION_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_2DSECTION_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPBDGELEVLINEPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPBDGELEVLINEPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPBDGELEVLINEPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPBDGELEVLINEPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPBDGSECTIONLINEPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPBDGSECTIONLINEPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPBDGSECTIONLINEPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPBDGSECTIONLINEPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCEILINGGRIDPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCEILINGGRIDPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCEILINGGRIDPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCEILINGGRIDPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCOLUMNGRIDPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCOLUMNGRIDPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCOLUMNGRIDPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCOLUMNGRIDPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLLAYOUTPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLLAYOUTPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLLAYOUTPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLLAYOUTPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLUNITPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLUNITPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLUNITPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPCURTAINWALLUNITPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPMVBLOCKREFPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPMVBLOCKREFPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPMVBLOCKREFPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPMVBLOCKREFPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPROOFPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPROOFPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPROOFPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPROOFPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPROOFSLABPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPROOFSLABPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPROOFSLABPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPROOFSLABPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPSLABPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPSLABPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPSLABPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPSLABPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPSPACEPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPSPACEPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPSPACEPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPSPACEPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPWALLPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPWALLPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPWALLPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPWALLPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPWINDOWASSEMBLYPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPWINDOWASSEMBLYPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPWINDOWASSEMBLYPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPWINDOWASSEMBLYPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPZONE100",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPZONE100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBDISPREPZONE50",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBDISPREPZONE50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBZONEDEF",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBZONEDEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_AECDBZONESTYLE",SWIG_From_int((int)(DWG_TYPE_AEC_AECDBZONESTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_ANCHOR_OPENINGBASE_TO_WALL",SWIG_From_int((int)(DWG_TYPE_AEC_ANCHOR_OPENINGBASE_TO_WALL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CLASSIFICATION_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_CLASSIFICATION_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CLASSIFICATION_SYSTEM_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_CLASSIFICATION_SYSTEM_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CLEANUP_GROUP_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_CLEANUP_GROUP_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CURTAIN_WALL_LAYOUT_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_CURTAIN_WALL_LAYOUT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CURTAIN_WALL_UNIT_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_CURTAIN_WALL_UNIT_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_CVSECTIONVIEW",SWIG_From_int((int)(DWG_TYPE_AEC_CVSECTIONVIEW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_DB_DISP_REP_DIM_GROUP_PLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DIM_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_DIM_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPLAYTHEME_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_DISPLAYTHEME_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_2D_SECTION",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_2D_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_CLIP_VOLUME",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_CLIP_VOLUME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_CLIP_VOLUME_RESULT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_CLIP_VOLUME_RESULT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DIM",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DIM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DISPLAYTHEME",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DISPLAYTHEME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR_NOMINAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR_NOMINAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR_THRESHOLD_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR_THRESHOLD_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_DOOR_THRESHOLD_SYMBOL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_DOOR_THRESHOLD_SYMBOL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_EDITINPLACEPROFILE_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_EDITINPLACEPROFILE_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ENT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ENT_REF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ENT_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_GRID_ASSEMBLY_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_GRID_ASSEMBLY_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_GRID_ASSEMBLY_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_GRID_ASSEMBLY_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_LAYOUT_CURVE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_LAYOUT_CURVE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_LAYOUT_GRID2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_LAYOUT_GRID2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_LAYOUT_GRID3D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_LAYOUT_GRID3D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_MASKBLOCK",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_MASKBLOCK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_MASS_ELEM_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_MASS_ELEM_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_MASS_GROUP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_MASS_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_MATERIAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_MATERIAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_OPENING",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_OPENING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_POLYGON_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_POLYGON_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_POLYGON_TRUECOLOUR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_POLYGON_TRUECOLOUR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_RAILING_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_RAILING_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_RAILING_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_RAILING_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ROOF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ROOF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ROOFSLAB",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ROOFSLAB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ROOFSLAB_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ROOFSLAB_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SCHEDULE_TABLE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SCHEDULE_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SLAB",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SLAB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SLAB_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SLAB_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SLICE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SLICE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SPACE_DECOMPOSED",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SPACE_DECOMPOSED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SPACE_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SPACE_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_SPACE_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_SPACE_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_STAIR_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_STAIR_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_STAIR_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_STAIR_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_STAIR_PLAN_OVERLAPPING",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_STAIR_PLAN_OVERLAPPING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WALL_GRAPH",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WALL_GRAPH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WALL_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WALL_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WALL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WALL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WALL_SCHEM",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WALL_SCHEM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW_ASSEMBLY_SILL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW_ASSEMBLY_SILL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW_NOMINAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW_NOMINAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_WINDOW_SILL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_WINDOW_SILL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_PROPS_ZONE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_PROPS_ZONE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_2D_SECTION",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_2D_SECTION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSELEMPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSELEMPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSELEMPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSELEMPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSGROUPPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSGROUPPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSGROUPPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPMASSGROUPPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLAN100",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLAN100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLAN50",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLAN50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLANREFLECTED",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGPLANREFLECTED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGSILLPLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISPREPAECDBDISPREPOPENINGSILLPLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_BUB_TO_GRID_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_ENT_TO_NODE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_ENT_TO_NODE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_EXT_TAG_TO_ENT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_EXT_TAG_TO_ENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ANCHOR_TAG_TO_ENT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ANCHOR_TAG_TO_ENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_ELEVLINE_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_SECTIONLINE_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_SECTION_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_SECTION_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_BDG_SECTION_SUBDIV",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_BDG_SECTION_SUBDIV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CEILING_GRID",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CEILING_GRID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CEILING_GRID_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CEILING_GRID_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CEILING_GRID_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CEILING_GRID_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_RESULT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_RESULT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_RESULT_SUBDIV",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CLIP_VOLUME_RESULT_SUBDIV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_BLOCK",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_BLOCK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CIRCARC2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CIRCARC2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONCOINCIDENT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONCOINCIDENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONCONCENTRIC",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONCONCENTRIC)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONEQUALDISTANCE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONEQUALDISTANCE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONMIDPOINT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONMIDPOINT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONNECTOR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONNECTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONNORMAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONNORMAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONPARALLEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONPARALLEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONPERPENDICULAR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONPERPENDICULAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONSYMMETRIC",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONSYMMETRIC)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_CONTANGENT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_CONTANGENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMANGLE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMANGLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMDIAMETER",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMDIAMETER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMDISTANCE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMDISTANCE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMLENGTH",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMLENGTH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMMAJORRADIUS",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMMAJORRADIUS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_DIMMINORRADIUS",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_DIMMINORRADIUS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_ELLIPARC2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_ELLIPARC2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_LAYOUTDATA",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_LAYOUTDATA)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_LINE2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_LINE2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_ADD",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_ADD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_CUTPLANE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_CUTPLANE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_EXTRUSION",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_EXTRUSION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_GROUP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_GROUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_LOFT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_LOFT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_PATH",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_PATH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_REVOLVE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_REVOLVE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_SUBTRACT",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_SUBTRACT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_TRANSITION",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_MODIFIER_TRANSITION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_POINT2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_POINT2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_PROFILE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_PROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COLUMN_GRID",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COLUMN_GRID)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COLUMN_GRID_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COLUMN_GRID_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COLUMN_GRID_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COLUMN_GRID_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_WORKPLANE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_WORKPLANE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_COL_WORKPLANE_REF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_COL_WORKPLANE_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CONFIG",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CONFIG)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_LAYOUT_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_LAYOUT_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_LAYOUT_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_LAYOUT_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_UNIT_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_UNIT_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_UNIT_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_CURTAIN_WALL_UNIT_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DCM_DIMRADIUS",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DCM_DIMRADIUS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DISPLAYTHEME",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DISPLAYTHEME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_ELEV",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_ELEV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_NOMINAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_NOMINAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_PLAN_HEKTO",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_PLAN_HEKTO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_THRESHOLD_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_THRESHOLD_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_DOOR_THRESHOLD_SYMBOL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_DOOR_THRESHOLD_SYMBOL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_EDITINPLACEPROFILE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_EDITINPLACEPROFILE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ENT_REF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ENT_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_LAYOUT_CURVE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_LAYOUT_CURVE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_LAYOUT_GRID2D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_LAYOUT_GRID2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_LAYOUT_GRID3D",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_LAYOUT_GRID3D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASKBLOCK_REF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASKBLOCK_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASKBLOCK_REF_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASKBLOCK_REF_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_ELEM_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_ELEM_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_ELEM_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_ELEM_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_ELEM_SCHEM",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_ELEM_SCHEM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_GROUP_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_GROUP_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_GROUP_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_GROUP_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MASS_GROUP_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MASS_GROUP_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MATERIAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MATERIAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_MVBLOCK_REF_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_OPENING",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_OPENING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_OPENING_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_OPENING_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_POLYGON_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_POLYGON_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_POLYGON_TRUECOLOUR",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_POLYGON_TRUECOLOUR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_RAILING_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_RAILING_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_RAILING_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_RAILING_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_RAILING_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_RAILING_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_RAILING_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_RAILING_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ROOF_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ROOF_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ROOF_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ROOF_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ROOF_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ROOF_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ROOFSLAB_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ROOFSLAB_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ROOFSLAB_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ROOFSLAB_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SCHEDULE_TABLE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SCHEDULE_TABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SET",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SLAB_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SLAB_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SLAB_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SLAB_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SLICE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SLICE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SPACE_DECOMPOSED",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SPACE_DECOMPOSED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SPACE_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SPACE_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SPACE_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SPACE_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SPACE_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SPACE_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_SPACE_VOLUME",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_SPACE_VOLUME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_OVERLAPPING",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_PLAN_OVERLAPPING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_STAIR_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_STAIR_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WALL_GRAPH",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WALL_GRAPH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WALL_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WALL_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WALL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WALL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WALL_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WALL_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WALL_SCHEM",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WALL_SCHEM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_ASSEMBLY_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_ASSEMBLY_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_ASSEMBLY_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_ASSEMBLY_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOWASSEMBLY_SILL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOWASSEMBLY_SILL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_ELEV",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_ELEV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_MODEL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_MODEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_NOMINAL",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_NOMINAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_RCP",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_RCP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_WINDOW_SILL_PLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_WINDOW_SILL_PLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_REP_ZONE",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_REP_ZONE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPROPSMASSELEMPLANCOMMON",SWIG_From_int((int)(DWG_TYPE_AEC_DISPROPSMASSELEMPLANCOMMON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPROPSMASSGROUPPLANCOMMON",SWIG_From_int((int)(DWG_TYPE_AEC_DISPROPSMASSGROUPPLANCOMMON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPROPSOPENINGPLANCOMMON",SWIG_From_int((int)(DWG_TYPE_AEC_DISPROPSOPENINGPLANCOMMON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPROPSOPENINGPLANCOMMONHATCHED",SWIG_From_int((int)(DWG_TYPE_AEC_DISPROPSOPENINGPLANCOMMONHATCHED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISPROPSOPENINGSILLPLAN",SWIG_From_int((int)(DWG_TYPE_AEC_DISPROPSOPENINGSILLPLAN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_ROPS_RAILING_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_ROPS_RAILING_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_ROPS_RAILING_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_ROPS_RAILING_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_ROPS_STAIR_PLAN_100",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_ROPS_STAIR_PLAN_100)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DISP_ROPS_STAIR_PLAN_50",SWIG_From_int((int)(DWG_TYPE_AEC_DISP_ROPS_STAIR_PLAN_50)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_DOOR_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_DOOR_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_ENDCAP_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_ENDCAP_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_FRAME_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_FRAME_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_LAYERKEY_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_LAYERKEY_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_LIST_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_LIST_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_MASKBLOCK_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_MASKBLOCK_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_MASS_ELEM_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_MASS_ELEM_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_MATERIAL_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_MATERIAL_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_MVBLOCK_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_MVBLOCK_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_MVBLOCK_REF",SWIG_From_int((int)(DWG_TYPE_AEC_MVBLOCK_REF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_NOTIFICATION_TRACKER",SWIG_From_int((int)(DWG_TYPE_AEC_NOTIFICATION_TRACKER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_POLYGON",SWIG_From_int((int)(DWG_TYPE_AEC_POLYGON)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_POLYGON_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_POLYGON_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_PROPERTY_SET_DEF",SWIG_From_int((int)(DWG_TYPE_AEC_PROPERTY_SET_DEF)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_RAILING_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_RAILING_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_REFEDIT_STATUS_TRACKER",SWIG_From_int((int)(DWG_TYPE_AEC_REFEDIT_STATUS_TRACKER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_ROOFSLABEDGE_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_ROOFSLABEDGE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_ROOFSLAB_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_ROOFSLAB_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_SCHEDULE_DATA_FORMAT",SWIG_From_int((int)(DWG_TYPE_AEC_SCHEDULE_DATA_FORMAT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_SLABEDGE_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_SLABEDGE_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_SLAB_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_SLAB_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_SPACE_STYLES",SWIG_From_int((int)(DWG_TYPE_AEC_SPACE_STYLES)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_STAIR_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_STAIR_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_STAIR_WINDER_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_STAIR_WINDER_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_STAIR_WINDER_TYPE_BALANCED",SWIG_From_int((int)(DWG_TYPE_AEC_STAIR_WINDER_TYPE_BALANCED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_STAIR_WINDER_TYPE_MANUAL",SWIG_From_int((int)(DWG_TYPE_AEC_STAIR_WINDER_TYPE_MANUAL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_STAIR_WINDER_TYPE_SINGLE_POINT",SWIG_From_int((int)(DWG_TYPE_AEC_STAIR_WINDER_TYPE_SINGLE_POINT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_VARS_AECBBLDSRV",SWIG_From_int((int)(DWG_TYPE_AEC_VARS_AECBBLDSRV)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_VARS_ARCHBASE",SWIG_From_int((int)(DWG_TYPE_AEC_VARS_ARCHBASE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_VARS_DWG_SETUP",SWIG_From_int((int)(DWG_TYPE_AEC_VARS_DWG_SETUP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_VARS_MUNICH",SWIG_From_int((int)(DWG_TYPE_AEC_VARS_MUNICH)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_VARS_STRUCTUREBASE",SWIG_From_int((int)(DWG_TYPE_AEC_VARS_STRUCTUREBASE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_WALLMOD_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_WALLMOD_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_WALL_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_WALL_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_WINDOW_ASSEMBLY_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_WINDOW_ASSEMBLY_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AEC_WINDOW_STYLE",SWIG_From_int((int)(DWG_TYPE_AEC_WINDOW_STYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ALIGNMENTGRIPENTITY",SWIG_From_int((int)(DWG_TYPE_ALIGNMENTGRIPENTITY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMCONTEXTMGR",SWIG_From_int((int)(DWG_TYPE_AMCONTEXTMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTADMENUSTATE",SWIG_From_int((int)(DWG_TYPE_AMDTADMENUSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTAMMENUSTATE",SWIG_From_int((int)(DWG_TYPE_AMDTAMMENUSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTBROWSERDBTAB",SWIG_From_int((int)(DWG_TYPE_AMDTBROWSERDBTAB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTDMMENUSTATE",SWIG_From_int((int)(DWG_TYPE_AMDTDMMENUSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTEDGESTANDARDDIN",SWIG_From_int((int)(DWG_TYPE_AMDTEDGESTANDARDDIN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTEDGESTANDARDDIN13715",SWIG_From_int((int)(DWG_TYPE_AMDTEDGESTANDARDDIN13715)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTEDGESTANDARDISO",SWIG_From_int((int)(DWG_TYPE_AMDTEDGESTANDARDISO)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTEDGESTANDARDISO13715",SWIG_From_int((int)(DWG_TYPE_AMDTEDGESTANDARDISO13715)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTFORMULAUPDATEDISPATCHER",SWIG_From_int((int)(DWG_TYPE_AMDTFORMULAUPDATEDISPATCHER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTINTERNALREACTOR",SWIG_From_int((int)(DWG_TYPE_AMDTINTERNALREACTOR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTMCOMMENUSTATE",SWIG_From_int((int)(DWG_TYPE_AMDTMCOMMENUSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTMENUSTATEMGR",SWIG_From_int((int)(DWG_TYPE_AMDTMENUSTATEMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTNOTE",SWIG_From_int((int)(DWG_TYPE_AMDTNOTE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTNOTETEMPLATEDB",SWIG_From_int((int)(DWG_TYPE_AMDTNOTETEMPLATEDB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTSECTIONSYM",SWIG_From_int((int)(DWG_TYPE_AMDTSECTIONSYM)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTSECTIONSYMLABEL",SWIG_From_int((int)(DWG_TYPE_AMDTSECTIONSYMLABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMDTSYSATTR",SWIG_From_int((int)(DWG_TYPE_AMDTSYSATTR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMGOBJPROPCFG",SWIG_From_int((int)(DWG_TYPE_AMGOBJPROPCFG)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMGSETTINGSOBJ",SWIG_From_int((int)(DWG_TYPE_AMGSETTINGSOBJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AMIMASTER",SWIG_From_int((int)(DWG_TYPE_AMIMASTER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AM_DRAWING_MGR",SWIG_From_int((int)(DWG_TYPE_AM_DRAWING_MGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AM_DWGMGR_NAME",SWIG_From_int((int)(DWG_TYPE_AM_DWGMGR_NAME)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AM_DWG_DOCUMENT",SWIG_From_int((int)(DWG_TYPE_AM_DWG_DOCUMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AM_DWG_SHEET",SWIG_From_int((int)(DWG_TYPE_AM_DWG_SHEET)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_AM_VIEWDIMPARMAP",SWIG_From_int((int)(DWG_TYPE_AM_VIEWDIMPARMAP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BINRECORD",SWIG_From_int((int)(DWG_TYPE_BINRECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CAMSCATALOGAPPOBJECT",SWIG_From_int((int)(DWG_TYPE_CAMSCATALOGAPPOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CAMSSTRUCTBTNSTATE",SWIG_From_int((int)(DWG_TYPE_CAMSSTRUCTBTNSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CATALOGSTATE",SWIG_From_int((int)(DWG_TYPE_CATALOGSTATE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CBROWSERAPPOBJECT",SWIG_From_int((int)(DWG_TYPE_CBROWSERAPPOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DEPMGR",SWIG_From_int((int)(DWG_TYPE_DEPMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMBASEELEMENT",SWIG_From_int((int)(DWG_TYPE_DMBASEELEMENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMDEFAULTSTYLE",SWIG_From_int((int)(DWG_TYPE_DMDEFAULTSTYLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMLEGEND",SWIG_From_int((int)(DWG_TYPE_DMLEGEND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMMAP",SWIG_From_int((int)(DWG_TYPE_DMMAP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMMAPMANAGER",SWIG_From_int((int)(DWG_TYPE_DMMAPMANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMSTYLECATEGORY",SWIG_From_int((int)(DWG_TYPE_DMSTYLECATEGORY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMSTYLELIBRARY",SWIG_From_int((int)(DWG_TYPE_DMSTYLELIBRARY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMSTYLEREFERENCE",SWIG_From_int((int)(DWG_TYPE_DMSTYLEREFERENCE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMSTYLIZEDENTITIESTABLE",SWIG_From_int((int)(DWG_TYPE_DMSTYLIZEDENTITIESTABLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DMSURROGATESTYLESETS",SWIG_From_int((int)(DWG_TYPE_DMSURROGATESTYLESETS)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DM_PLACEHOLDER",SWIG_From_int((int)(DWG_TYPE_DM_PLACEHOLDER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXACTERMXREFMAP",SWIG_From_int((int)(DWG_TYPE_EXACTERMXREFMAP)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXACXREFPANELOBJECT",SWIG_From_int((int)(DWG_TYPE_EXACXREFPANELOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXPO_NOTIFYBLOCK",SWIG_From_int((int)(DWG_TYPE_EXPO_NOTIFYBLOCK)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXPO_NOTIFYHALL",SWIG_From_int((int)(DWG_TYPE_EXPO_NOTIFYHALL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXPO_NOTIFYPILLAR",SWIG_From_int((int)(DWG_TYPE_EXPO_NOTIFYPILLAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXPO_NOTIFYSTAND",SWIG_From_int((int)(DWG_TYPE_EXPO_NOTIFYSTAND)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_EXPO_NOTIFYSTANDNOPOLY",SWIG_From_int((int)(DWG_TYPE_EXPO_NOTIFYSTANDNOPOLY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_GSMANAGER",SWIG_From_int((int)(DWG_TYPE_GSMANAGER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IRD_DSC_DICT",SWIG_From_int((int)(DWG_TYPE_IRD_DSC_DICT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IRD_DSC_RECORD",SWIG_From_int((int)(DWG_TYPE_IRD_DSC_RECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_IRD_OBJ_RECORD",SWIG_From_int((int)(DWG_TYPE_IRD_OBJ_RECORD)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MAPFSMRVOBJECT",SWIG_From_int((int)(DWG_TYPE_MAPFSMRVOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MAPGWSUNDOOBJECT",SWIG_From_int((int)(DWG_TYPE_MAPGWSUNDOOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MAPIAMMOUDLE",SWIG_From_int((int)(DWG_TYPE_MAPIAMMOUDLE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MAPMETADATAOBJECT",SWIG_From_int((int)(DWG_TYPE_MAPMETADATAOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_MAPRESOURCEMANAGEROBJECT",SWIG_From_int((int)(DWG_TYPE_MAPRESOURCEMANAGEROBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_McDbContainer2",SWIG_From_int((int)(DWG_TYPE_McDbContainer2)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_McDbMarker",SWIG_From_int((int)(DWG_TYPE_McDbMarker)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NAMEDAPPL",SWIG_From_int((int)(DWG_TYPE_NAMEDAPPL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NEWSTDPARTPARLIST",SWIG_From_int((int)(DWG_TYPE_NEWSTDPARTPARLIST)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_NOTEPOSITION",SWIG_From_int((int)(DWG_TYPE_NOTEPOSITION)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_OBJCLONER",SWIG_From_int((int)(DWG_TYPE_OBJCLONER)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PARAMMGR",SWIG_From_int((int)(DWG_TYPE_PARAMMGR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PARAMSCOPE",SWIG_From_int((int)(DWG_TYPE_PARAMSCOPE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_PILLAR",SWIG_From_int((int)(DWG_TYPE_PILLAR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_STDPART2D",SWIG_From_int((int)(DWG_TYPE_STDPART2D)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_ARROW",SWIG_From_int((int)(DWG_TYPE_TCH_ARROW)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_AXIS_LABEL",SWIG_From_int((int)(DWG_TYPE_TCH_AXIS_LABEL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_BLOCK_INSERT",SWIG_From_int((int)(DWG_TYPE_TCH_BLOCK_INSERT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_COLUMN",SWIG_From_int((int)(DWG_TYPE_TCH_COLUMN)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_DBCONFIG",SWIG_From_int((int)(DWG_TYPE_TCH_DBCONFIG)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_DIMENSION2",SWIG_From_int((int)(DWG_TYPE_TCH_DIMENSION2)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_DRAWINGINDEX",SWIG_From_int((int)(DWG_TYPE_TCH_DRAWINGINDEX)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_HANDRAIL",SWIG_From_int((int)(DWG_TYPE_TCH_HANDRAIL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_LINESTAIR",SWIG_From_int((int)(DWG_TYPE_TCH_LINESTAIR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_OPENING",SWIG_From_int((int)(DWG_TYPE_TCH_OPENING)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_RECTSTAIR",SWIG_From_int((int)(DWG_TYPE_TCH_RECTSTAIR)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_SLAB",SWIG_From_int((int)(DWG_TYPE_TCH_SLAB)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_SPACE",SWIG_From_int((int)(DWG_TYPE_TCH_SPACE)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_TEXT",SWIG_From_int((int)(DWG_TYPE_TCH_TEXT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TCH_WALL",SWIG_From_int((int)(DWG_TYPE_TCH_WALL)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TGrupoPuntos",SWIG_From_int((int)(DWG_TYPE_TGrupoPuntos)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VAACIMAGEINVENTORY",SWIG_From_int((int)(DWG_TYPE_VAACIMAGEINVENTORY)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VAACXREFPANELOBJECT",SWIG_From_int((int)(DWG_TYPE_VAACXREFPANELOBJECT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_FREED",SWIG_From_int((int)(DWG_TYPE_FREED)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UNKNOWN_ENT",SWIG_From_int((int)(DWG_TYPE_UNKNOWN_ENT)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UNKNOWN_OBJ",SWIG_From_int((int)(DWG_TYPE_UNKNOWN_OBJ)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UNUSED_r11",SWIG_From_int((int)(DWG_TYPE_UNUSED_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LINE_r11",SWIG_From_int((int)(DWG_TYPE_LINE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POINT_r11",SWIG_From_int((int)(DWG_TYPE_POINT_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_CIRCLE_r11",SWIG_From_int((int)(DWG_TYPE_CIRCLE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SHAPE_r11",SWIG_From_int((int)(DWG_TYPE_SHAPE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_REPEAT_r11",SWIG_From_int((int)(DWG_TYPE_REPEAT_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ENDREP_r11",SWIG_From_int((int)(DWG_TYPE_ENDREP_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TEXT_r11",SWIG_From_int((int)(DWG_TYPE_TEXT_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ARC_r11",SWIG_From_int((int)(DWG_TYPE_ARC_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_TRACE_r11",SWIG_From_int((int)(DWG_TYPE_TRACE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_LOAD_r11",SWIG_From_int((int)(DWG_TYPE_LOAD_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SOLID_r11",SWIG_From_int((int)(DWG_TYPE_SOLID_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_BLOCK_r11",SWIG_From_int((int)(DWG_TYPE_BLOCK_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ENDBLK_r11",SWIG_From_int((int)(DWG_TYPE_ENDBLK_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_INSERT_r11",SWIG_From_int((int)(DWG_TYPE_INSERT_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ATTDEF_r11",SWIG_From_int((int)(DWG_TYPE_ATTDEF_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_ATTRIB_r11",SWIG_From_int((int)(DWG_TYPE_ATTRIB_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_SEQEND_r11",SWIG_From_int((int)(DWG_TYPE_SEQEND_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_JUMP_r11",SWIG_From_int((int)(DWG_TYPE_JUMP_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_POLYLINE_r11",SWIG_From_int((int)(DWG_TYPE_POLYLINE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VERTEX_r11",SWIG_From_int((int)(DWG_TYPE_VERTEX_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_3DLINE_r11",SWIG_From_int((int)(DWG_TYPE_3DLINE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_3DFACE_r11",SWIG_From_int((int)(DWG_TYPE_3DFACE_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_DIMENSION_r11",SWIG_From_int((int)(DWG_TYPE_DIMENSION_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_VIEWPORT_r11",SWIG_From_int((int)(DWG_TYPE_VIEWPORT_r11)));
  SWIG_Python_SetConstant(d, "DWG_TYPE_UNKNOWN_r11",SWIG_From_int((int)(DWG_TYPE_UNKNOWN_r11)));
  SWIG_Python_SetConstant(d, "DWG_NOERR",SWIG_From_int((int)(DWG_NOERR)));
  SWIG_Python_SetConstant(d, "DWG_ERR_WRONGCRC",SWIG_From_int((int)(DWG_ERR_WRONGCRC)));
  SWIG_Python_SetConstant(d, "DWG_ERR_NOTYETSUPPORTED",SWIG_From_int((int)(DWG_ERR_NOTYETSUPPORTED)));
  SWIG_Python_SetConstant(d, "DWG_ERR_UNHANDLEDCLASS",SWIG_From_int((int)(DWG_ERR_UNHANDLEDCLASS)));
  SWIG_Python_SetConstant(d, "DWG_ERR_INVALIDTYPE",SWIG_From_int((int)(DWG_ERR_INVALIDTYPE)));
  SWIG_Python_SetConstant(d, "DWG_ERR_INVALIDHANDLE",SWIG_From_int((int)(DWG_ERR_INVALIDHANDLE)));
  SWIG_Python_SetConstant(d, "DWG_ERR_INVALIDEED",SWIG_From_int((int)(DWG_ERR_INVALIDEED)));
  SWIG_Python_SetConstant(d, "DWG_ERR_VALUEOUTOFBOUNDS",SWIG_From_int((int)(DWG_ERR_VALUEOUTOFBOUNDS)));
  SWIG_Python_SetConstant(d, "DWG_ERR_CLASSESNOTFOUND",SWIG_From_int((int)(DWG_ERR_CLASSESNOTFOUND)));
  SWIG_Python_SetConstant(d, "DWG_ERR_SECTIONNOTFOUND",SWIG_From_int((int)(DWG_ERR_SECTIONNOTFOUND)));
  SWIG_Python_SetConstant(d, "DWG_ERR_PAGENOTFOUND",SWIG_From_int((int)(DWG_ERR_PAGENOTFOUND)));
  SWIG_Python_SetConstant(d, "DWG_ERR_INTERNALERROR",SWIG_From_int((int)(DWG_ERR_INTERNALERROR)));
  SWIG_Python_SetConstant(d, "DWG_ERR_INVALIDDWG",SWIG_From_int((int)(DWG_ERR_INVALIDDWG)));
  SWIG_Python_SetConstant(d, "DWG_ERR_IOERROR",SWIG_From_int((int)(DWG_ERR_IOERROR)));
  SWIG_Python_SetConstant(d, "DWG_ERR_OUTOFMEM",SWIG_From_int((int)(DWG_ERR_OUTOFMEM)));
  SWIG_Python_SetConstant(d, "DWG_HDL_OWNER",SWIG_From_int((int)(DWG_HDL_OWNER)));
  SWIG_Python_SetConstant(d, "DWG_HDL_SOFTOWN",SWIG_From_int((int)(DWG_HDL_SOFTOWN)));
  SWIG_Python_SetConstant(d, "DWG_HDL_HARDOWN",SWIG_From_int((int)(DWG_HDL_HARDOWN)));
  SWIG_Python_SetConstant(d, "DWG_HDL_SOFTPTR",SWIG_From_int((int)(DWG_HDL_SOFTPTR)));
  SWIG_Python_SetConstant(d, "DWG_HDL_HARDPTR",SWIG_From_int((int)(DWG_HDL_HARDPTR)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_VOID",SWIG_From_int((int)(DWG_COLOR_METHOD_VOID)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_BYLAYER",SWIG_From_int((int)(DWG_COLOR_METHOD_BYLAYER)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_BYBLOCK",SWIG_From_int((int)(DWG_COLOR_METHOD_BYBLOCK)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_ACI",SWIG_From_int((int)(DWG_COLOR_METHOD_ACI)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_TRUECOLOR",SWIG_From_int((int)(DWG_COLOR_METHOD_TRUECOLOR)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_FGCOLOR",SWIG_From_int((int)(DWG_COLOR_METHOD_FGCOLOR)));
  SWIG_Python_SetConstant(d, "DWG_COLOR_METHOD_NONE",SWIG_From_int((int)(DWG_COLOR_METHOD_NONE)));
  SWIG_Python_SetConstant(d, "SPLINETYPE_QUADRATIC",SWIG_From_int((int)(SPLINETYPE_QUADRATIC)));
  SWIG_Python_SetConstant(d, "SPLINETYPE_CUBIC",SWIG_From_int((int)(SPLINETYPE_CUBIC)));
  SWIG_Python_SetConstant(d, "SPLINE_SCENARIO_SPLINE",SWIG_From_int((int)(SPLINE_SCENARIO_SPLINE)));
  SWIG_Python_SetConstant(d, "SPLINE_SCENARIO_BEZIER",SWIG_From_int((int)(SPLINE_SCENARIO_BEZIER)));
  SWIG_Python_SetConstant(d, "SPLINE_SPLINEFLAGS_METHOD_FIT_POINTS",SWIG_From_int((int)(SPLINE_SPLINEFLAGS_METHOD_FIT_POINTS)));
  SWIG_Python_SetConstant(d, "SPLINE_SPLINEFLAGS_CV_FRAME_SHOW",SWIG_From_int((int)(SPLINE_SPLINEFLAGS_CV_FRAME_SHOW)));
  SWIG_Python_SetConstant(d, "SPLINE_SPLINEFLAGS_CLOSED",SWIG_From_int((int)(SPLINE_SPLINEFLAGS_CLOSED)));
  SWIG_Python_SetConstant(d, "SPLINE_KNOTPARAM_CHORD",SWIG_From_int((int)(SPLINE_KNOTPARAM_CHORD)));
  SWIG_Python_SetConstant(d, "SPLINE_KNOTPARAM_SQUARE_ROOT",SWIG_From_int((int)(SPLINE_KNOTPARAM_SQUARE_ROOT)));
  SWIG_Python_SetConstant(d, "SPLINE_KNOTPARAM_UNIFORM",SWIG_From_int((int)(SPLINE_KNOTPARAM_UNIFORM)));
  SWIG_Python_SetConstant(d, "SPLINE_KNOTPARAM_CUSTOM",SWIG_From_int((int)(SPLINE_KNOTPARAM_CUSTOM)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_1",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_1)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_HAS_EED",SWIG_From_int((int)(EXTRA_R11_HAS_EED)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_HAS_VIEWPORT",SWIG_From_int((int)(EXTRA_R11_HAS_VIEWPORT)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_8",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_8)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_16",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_16)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_32",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_32)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_64",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_64)));
  SWIG_Python_SetConstant(d, "EXTRA_R11_UNKNOWN_128",SWIG_From_int((int)(EXTRA_R11_UNKNOWN_128)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_COLOR",SWIG_From_int((int)(FLAG_R11_HAS_COLOR)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_LTYPE",SWIG_From_int((int)(FLAG_R11_HAS_LTYPE)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_ELEVATION",SWIG_From_int((int)(FLAG_R11_HAS_ELEVATION)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_THICKNESS",SWIG_From_int((int)(FLAG_R11_HAS_THICKNESS)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_UNKNOWN_16",SWIG_From_int((int)(FLAG_R11_HAS_UNKNOWN_16)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_HANDLING",SWIG_From_int((int)(FLAG_R11_HAS_HANDLING)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_PSPACE",SWIG_From_int((int)(FLAG_R11_HAS_PSPACE)));
  SWIG_Python_SetConstant(d, "FLAG_R11_HAS_ATTRIBS",SWIG_From_int((int)(FLAG_R11_HAS_ATTRIBS)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_LINEAR",SWIG_From_int((int)(FLAG_R11_DIMENSION_LINEAR)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_ALIGNED",SWIG_From_int((int)(FLAG_R11_DIMENSION_ALIGNED)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_ANG2LN",SWIG_From_int((int)(FLAG_R11_DIMENSION_ANG2LN)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_DIAMETER",SWIG_From_int((int)(FLAG_R11_DIMENSION_DIAMETER)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_RADIUS",SWIG_From_int((int)(FLAG_R11_DIMENSION_RADIUS)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_ANG3PT",SWIG_From_int((int)(FLAG_R11_DIMENSION_ANG3PT)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_ORDINATE",SWIG_From_int((int)(FLAG_R11_DIMENSION_ORDINATE)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_ORDINATE_TYPE",SWIG_From_int((int)(FLAG_R11_DIMENSION_ORDINATE_TYPE)));
  SWIG_Python_SetConstant(d, "FLAG_R11_DIMENSION_TEXT_POSITIONED",SWIG_From_int((int)(FLAG_R11_DIMENSION_TEXT_POSITIONED)));
  SWIG_Python_SetConstant(d, "OPTS_R11_XREF_DEP",SWIG_From_int((int)(OPTS_R11_XREF_DEP)));
  SWIG_Python_SetConstant(d, "OPTS_R11_XREF_REF",SWIG_From_int((int)(OPTS_R11_XREF_REF)));
  SWIG_Python_SetConstant(d, "OPTS_R11_XREF_RESOLVED",SWIG_From_int((int)(OPTS_R11_XREF_RESOLVED)));
  SWIG_Python_SetConstant(d, "OPTS_R11_XDATA",SWIG_From_int((int)(OPTS_R11_XDATA)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DFACE_HAS_Z_FIRST",SWIG_From_int((int)(OPTS_R11_3DFACE_HAS_Z_FIRST)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DFACE_HAS_Z_SECOND",SWIG_From_int((int)(OPTS_R11_3DFACE_HAS_Z_SECOND)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DFACE_HAS_Z_THIRD",SWIG_From_int((int)(OPTS_R11_3DFACE_HAS_Z_THIRD)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DFACE_HAS_Z_FOURTH",SWIG_From_int((int)(OPTS_R11_3DFACE_HAS_Z_FOURTH)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DLINE_HAS_Z_FIRST",SWIG_From_int((int)(OPTS_R11_3DLINE_HAS_Z_FIRST)));
  SWIG_Python_SetConstant(d, "OPTS_R11_3DLINE_HAS_Z_SECOND",SWIG_From_int((int)(OPTS_R11_3DLINE_HAS_Z_SECOND)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ARC_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_ARC_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_UNKNOWN_1",SWIG_From_int((int)(OPTS_R11_ATTDEF_UNKNOWN_1)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_WIDTH_FACTOR",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_WIDTH_FACTOR)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_OBLIQUE_ANGLE",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_OBLIQUE_ANGLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_STYLE",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_STYLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_GENERATION",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_GENERATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_HORIZ_ALIGNMENT",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_HORIZ_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_ALIGNMENT_POINT",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_ALIGNMENT_POINT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTDEF_HAS_VERT_ALIGNMENT",SWIG_From_int((int)(OPTS_R11_ATTDEF_HAS_VERT_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_UNKNOWN_1",SWIG_From_int((int)(OPTS_R11_ATTRIB_UNKNOWN_1)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_WIDTH_FACTOR",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_WIDTH_FACTOR)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_OBLIQUE_ANGLE",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_OBLIQUE_ANGLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_STYLE",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_STYLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_GENERATION",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_GENERATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_HORIZ_ALIGNMENT",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_HORIZ_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_ALIGNMENT_POINT",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_ALIGNMENT_POINT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_ATTRIB_HAS_VERT_ALIGNMENT",SWIG_From_int((int)(OPTS_R11_ATTRIB_HAS_VERT_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_BLOCK_UNKNOWN_1",SWIG_From_int((int)(OPTS_R11_BLOCK_UNKNOWN_1)));
  SWIG_Python_SetConstant(d, "OPTS_R11_BLOCK_HAS_XREF_PNAME",SWIG_From_int((int)(OPTS_R11_BLOCK_HAS_XREF_PNAME)));
  SWIG_Python_SetConstant(d, "OPTS_R11_BLOCK_HAS_BLOCK_NAME",SWIG_From_int((int)(OPTS_R11_BLOCK_HAS_BLOCK_NAME)));
  SWIG_Python_SetConstant(d, "OPTS_R11_CIRCLE_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_CIRCLE_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF12",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF12)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_FLAG",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_FLAG)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_TEXT",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_TEXT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF13",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF13)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF14",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF14)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF15",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF15)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_ANGLES",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_ANGLES)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF40",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF40)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_UNKNOWN_512",SWIG_From_int((int)(OPTS_R11_DIMENSION_UNKNOWN_512)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DXF53",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DXF53)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_UNKNOWN_2048",SWIG_From_int((int)(OPTS_R11_DIMENSION_UNKNOWN_2048)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_UNKNOWN_4096",SWIG_From_int((int)(OPTS_R11_DIMENSION_UNKNOWN_4096)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_UNKNOWN_8192",SWIG_From_int((int)(OPTS_R11_DIMENSION_UNKNOWN_8192)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_DIMENSION_HAS_DIMSTYLE",SWIG_From_int((int)(OPTS_R11_DIMENSION_HAS_DIMSTYLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_SCALE_X",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_SCALE_X)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_SCALE_Y",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_SCALE_Y)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_SCALE_Z",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_SCALE_Z)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_NUM_COLS",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_NUM_COLS)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_NUM_ROWS",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_NUM_ROWS)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_COL_SPACING",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_COL_SPACING)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_ROW_SPACING",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_ROW_SPACING)));
  SWIG_Python_SetConstant(d, "OPTS_R11_INSERT_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_INSERT_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_LINE_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_LINE_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POINT_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_POINT_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POINT_HAS_X_ANG",SWIG_From_int((int)(OPTS_R11_POINT_HAS_X_ANG)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_FLAG",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_FLAG)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_START_WIDTH",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_START_WIDTH)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_END_WIDTH",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_END_WIDTH)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_M_VERTS",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_M_VERTS)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_N_VERTS",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_N_VERTS)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_M_DENSITY",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_M_DENSITY)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_N_DENSITY",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_N_DENSITY)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_HAS_CURVETYPE",SWIG_From_int((int)(OPTS_R11_POLYLINE_HAS_CURVETYPE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_POLYLINE_IN_EXTRA",SWIG_From_int((int)(OPTS_R11_POLYLINE_IN_EXTRA)));
  SWIG_Python_SetConstant(d, "OPTS_R11_SHAPE_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_SHAPE_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_SHAPE_HAS_LOAD_NUM",SWIG_From_int((int)(OPTS_R11_SHAPE_HAS_LOAD_NUM)));
  SWIG_Python_SetConstant(d, "OPTS_R11_SHAPE_HAS_WIDTH_FACTOR",SWIG_From_int((int)(OPTS_R11_SHAPE_HAS_WIDTH_FACTOR)));
  SWIG_Python_SetConstant(d, "OPTS_R11_SHAPE_HAS_OBLIQUE_ANGLE",SWIG_From_int((int)(OPTS_R11_SHAPE_HAS_OBLIQUE_ANGLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_SOLID_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_SOLID_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_ROTATION",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_ROTATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_WIDTH_FACTOR",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_WIDTH_FACTOR)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_OBLIQUE_ANGLE",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_OBLIQUE_ANGLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_STYLE",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_STYLE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_GENERATION",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_GENERATION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_HORIZ_ALIGNMENT",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_HORIZ_ALIGNMENT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_ALIGNMENT_POINT",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_ALIGNMENT_POINT)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_HAS_EXTRUSION",SWIG_From_int((int)(OPTS_R11_TEXT_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "OPTS_R11_TEXT_ALIGNED_VERT_TO",SWIG_From_int((int)(OPTS_R11_TEXT_ALIGNED_VERT_TO)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_START_WIDTH",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_START_WIDTH)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_END_WIDTH",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_END_WIDTH)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_BULGE",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_BULGE)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_FLAG",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_FLAG)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_TANGENT_DIR",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_TANGENT_DIR)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_INDEX1",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_INDEX1)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_INDEX2",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_INDEX2)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_INDEX3",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_INDEX3)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_INDEX4",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_INDEX4)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_UNKNOWN_512",SWIG_From_int((int)(OPTS_R11_VERTEX_UNKNOWN_512)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_UNKNOWN_1024",SWIG_From_int((int)(OPTS_R11_VERTEX_UNKNOWN_1024)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_UNKNOWN_2048",SWIG_From_int((int)(OPTS_R11_VERTEX_UNKNOWN_2048)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_UNKNOWN_4096",SWIG_From_int((int)(OPTS_R11_VERTEX_UNKNOWN_4096)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_UNKNOWN_8192",SWIG_From_int((int)(OPTS_R11_VERTEX_UNKNOWN_8192)));
  SWIG_Python_SetConstant(d, "OPTS_R11_VERTEX_HAS_NOT_X_Y",SWIG_From_int((int)(OPTS_R11_VERTEX_HAS_NOT_X_Y)));
  SWIG_Python_SetConstant(d, "FLAG_TABLE_IS_XREF_REF",SWIG_From_int((int)(FLAG_TABLE_IS_XREF_REF)));
  SWIG_Python_SetConstant(d, "FLAG_TABLE_IS_XREF_RESOLVED",SWIG_From_int((int)(FLAG_TABLE_IS_XREF_RESOLVED)));
  SWIG_Python_SetConstant(d, "FLAG_TABLE_IS_XREF_DEP",SWIG_From_int((int)(FLAG_TABLE_IS_XREF_DEP)));
  SWIG_Python_SetConstant(d, "FLAG_TABLE_IS_REMOVED",SWIG_From_int((int)(FLAG_TABLE_IS_REMOVED)));
  SWIG_Python_SetConstant(d, "FLAG_BLOCK_ANONYMOUS",SWIG_From_int((int)(FLAG_BLOCK_ANONYMOUS)));
  SWIG_Python_SetConstant(d, "FLAG_BLOCK_HAS_ATTRIBS",SWIG_From_int((int)(FLAG_BLOCK_HAS_ATTRIBS)));
  SWIG_Python_SetConstant(d, "FLAG_BLOCK_IS_EXT_REF",SWIG_From_int((int)(FLAG_BLOCK_IS_EXT_REF)));
  SWIG_Python_SetConstant(d, "FLAG_BLOCK_IS_XREF_OVERLAY",SWIG_From_int((int)(FLAG_BLOCK_IS_XREF_OVERLAY)));
  SWIG_Python_SetConstant(d, "FLAG_ATTDEF_INVISIBLE",SWIG_From_int((int)(FLAG_ATTDEF_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FLAG_ATTDEF_CONSTANT",SWIG_From_int((int)(FLAG_ATTDEF_CONSTANT)));
  SWIG_Python_SetConstant(d, "FLAG_ATTDEF_VERIFY",SWIG_From_int((int)(FLAG_ATTDEF_VERIFY)));
  SWIG_Python_SetConstant(d, "FLAG_ATTDEF_PRESET",SWIG_From_int((int)(FLAG_ATTDEF_PRESET)));
  SWIG_Python_SetConstant(d, "FLAG_ATTRIB_INVISIBLE",SWIG_From_int((int)(FLAG_ATTRIB_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FLAG_ATTRIB_CONSTANT",SWIG_From_int((int)(FLAG_ATTRIB_CONSTANT)));
  SWIG_Python_SetConstant(d, "FLAG_ATTRIB_VERIFY",SWIG_From_int((int)(FLAG_ATTRIB_VERIFY)));
  SWIG_Python_SetConstant(d, "FLAG_ATTRIB_PRESET",SWIG_From_int((int)(FLAG_ATTRIB_PRESET)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_CLOSED",SWIG_From_int((int)(FLAG_POLYLINE_CLOSED)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_CURVE_FIT",SWIG_From_int((int)(FLAG_POLYLINE_CURVE_FIT)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_SPLINE_FIT",SWIG_From_int((int)(FLAG_POLYLINE_SPLINE_FIT)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_3D",SWIG_From_int((int)(FLAG_POLYLINE_3D)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_MESH",SWIG_From_int((int)(FLAG_POLYLINE_MESH)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_MESH_CLOSED",SWIG_From_int((int)(FLAG_POLYLINE_MESH_CLOSED)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_PFACE_MESH",SWIG_From_int((int)(FLAG_POLYLINE_PFACE_MESH)));
  SWIG_Python_SetConstant(d, "FLAG_POLYLINE_LT_PATTERN_CONTINUES",SWIG_From_int((int)(FLAG_POLYLINE_LT_PATTERN_CONTINUES)));
  SWIG_Python_SetConstant(d, "LTYPE_SHAPE_FLAG_ABS_ROTATION",SWIG_From_int((int)(LTYPE_SHAPE_FLAG_ABS_ROTATION)));
  SWIG_Python_SetConstant(d, "LTYPE_SHAPE_FLAG_IS_TEXT",SWIG_From_int((int)(LTYPE_SHAPE_FLAG_IS_TEXT)));
  SWIG_Python_SetConstant(d, "LTYPE_SHAPE_FLAG_IS_SHAPE",SWIG_From_int((int)(LTYPE_SHAPE_FLAG_IS_SHAPE)));
  SWIG_Python_SetConstant(d, "FLAG_LAYER_FROZEN",SWIG_From_int((int)(FLAG_LAYER_FROZEN)));
  SWIG_Python_SetConstant(d, "FLAG_LAYER_FROZEN_IN_NEW",SWIG_From_int((int)(FLAG_LAYER_FROZEN_IN_NEW)));
  SWIG_Python_SetConstant(d, "FLAG_LAYER_LOCKED",SWIG_From_int((int)(FLAG_LAYER_LOCKED)));
  SWIG_Python_SetConstant(d, "FLAG_LAYER_PLOTFLAG",SWIG_From_int((int)(FLAG_LAYER_PLOTFLAG)));
  SWIG_Python_SetConstant(d, "FLAG_STYLE_SHAPE",SWIG_From_int((int)(FLAG_STYLE_SHAPE)));
  SWIG_Python_SetConstant(d, "FLAG_STYLE_VERTICAL_TEXT",SWIG_From_int((int)(FLAG_STYLE_VERTICAL_TEXT)));
  SWIG_Python_SetConstant(d, "FLAG_VIEW_PSPACE",SWIG_From_int((int)(FLAG_VIEW_PSPACE)));
  SWIG_Python_SetConstant(d, "FLAG_VX_IS_ON",SWIG_From_int((int)(FLAG_VX_IS_ON)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_EXTRUSION",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_EXTRUSION)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_THICKNESS",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_THICKNESS)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_CONSTWIDTH",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_CONSTWIDTH)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_ELEVATION",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_ELEVATION)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_NUM_BULGES",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_NUM_BULGES)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_HAS_NUM_WIDTHS",SWIG_From_int((int)(FLAG_LWPOLYLINE_HAS_NUM_WIDTHS)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_UNKNOWN_64",SWIG_From_int((int)(FLAG_LWPOLYLINE_UNKNOWN_64)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_UNKNOWN_128",SWIG_From_int((int)(FLAG_LWPOLYLINE_UNKNOWN_128)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_PLINEGEN",SWIG_From_int((int)(FLAG_LWPOLYLINE_PLINEGEN)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_CLOSED",SWIG_From_int((int)(FLAG_LWPOLYLINE_CLOSED)));
  SWIG_Python_SetConstant(d, "FLAG_LWPOLYLINE_VERTEXIDCOUNT",SWIG_From_int((int)(FLAG_LWPOLYLINE_VERTEXIDCOUNT)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_EXTRA_VERTEX",SWIG_From_int((int)(FLAG_VERTEX_EXTRA_VERTEX)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_CURVE_FIT",SWIG_From_int((int)(FLAG_VERTEX_CURVE_FIT)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_UNUSED_4",SWIG_From_int((int)(FLAG_VERTEX_UNUSED_4)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_SPLINE_FIT",SWIG_From_int((int)(FLAG_VERTEX_SPLINE_FIT)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_SPLINE_FRAME_CONTROL_POINT",SWIG_From_int((int)(FLAG_VERTEX_SPLINE_FRAME_CONTROL_POINT)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_3D",SWIG_From_int((int)(FLAG_VERTEX_3D)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_MESH",SWIG_From_int((int)(FLAG_VERTEX_MESH)));
  SWIG_Python_SetConstant(d, "FLAG_VERTEX_PFACE_MESH",SWIG_From_int((int)(FLAG_VERTEX_PFACE_MESH)));
  SWIG_Python_SetConstant(d, "TEXT_GENERATION_BACKWARDS",SWIG_From_int((int)(TEXT_GENERATION_BACKWARDS)));
  SWIG_Python_SetConstant(d, "TEXT_GENERATION_UPSIDE_DOWN",SWIG_From_int((int)(TEXT_GENERATION_UPSIDE_DOWN)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_LEFT",SWIG_From_int((int)(HORIZ_ALIGNMENT_LEFT)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_CENTER",SWIG_From_int((int)(HORIZ_ALIGNMENT_CENTER)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_RIGHT",SWIG_From_int((int)(HORIZ_ALIGNMENT_RIGHT)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_ALIGNED",SWIG_From_int((int)(HORIZ_ALIGNMENT_ALIGNED)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_MIDDLE",SWIG_From_int((int)(HORIZ_ALIGNMENT_MIDDLE)));
  SWIG_Python_SetConstant(d, "HORIZ_ALIGNMENT_FIT",SWIG_From_int((int)(HORIZ_ALIGNMENT_FIT)));
  SWIG_Python_SetConstant(d, "VERT_ALIGNMENT_BASELINE",SWIG_From_int((int)(VERT_ALIGNMENT_BASELINE)));
  SWIG_Python_SetConstant(d, "VERT_ALIGNMENT_BOTTOM",SWIG_From_int((int)(VERT_ALIGNMENT_BOTTOM)));
  SWIG_Python_SetConstant(d, "VERT_ALIGNMENT_MIDDLE",SWIG_From_int((int)(VERT_ALIGNMENT_MIDDLE)));
  SWIG_Python_SetConstant(d, "VERT_ALIGNMENT_TOP",SWIG_From_int((int)(VERT_ALIGNMENT_TOP)));
  SWIG_Python_SetConstant(d, "MLINE_JUSTIFICATION_TOP",SWIG_From_int((int)(MLINE_JUSTIFICATION_TOP)));
  SWIG_Python_SetConstant(d, "MLINE_JUSTIFICATION_MIDDLE",SWIG_From_int((int)(MLINE_JUSTIFICATION_MIDDLE)));
  SWIG_Python_SetConstant(d, "MLINE_JUSTIFICATION_BOTTOM",SWIG_From_int((int)(MLINE_JUSTIFICATION_BOTTOM)));
  SWIG_Python_SetConstant(d, "POLYLINE_CURVETYPE_DEFAULT",SWIG_From_int((int)(POLYLINE_CURVETYPE_DEFAULT)));
  SWIG_Python_SetConstant(d, "POLYLINE_CURVETYPE_QUADR_BSPLINE",SWIG_From_int((int)(POLYLINE_CURVETYPE_QUADR_BSPLINE)));
  SWIG_Python_SetConstant(d, "POLYLINE_CURVETYPE_CUBIC_BSPLINE",SWIG_From_int((int)(POLYLINE_CURVETYPE_CUBIC_BSPLINE)));
  SWIG_Python_SetConstant(d, "POLYLINE_CURVETYPE_BEZIER_SURFACE",SWIG_From_int((int)(POLYLINE_CURVETYPE_BEZIER_SURFACE)));
  SWIG_Python_SetConstant(d, "LEADER_PATHTYPE_STRAIGHT",SWIG_From_int((int)(LEADER_PATHTYPE_STRAIGHT)));
  SWIG_Python_SetConstant(d, "LEADER_PATHTYPE_SPLINE",SWIG_From_int((int)(LEADER_PATHTYPE_SPLINE)));
  SWIG_Python_SetConstant(d, "LEADER_ANNOTTYPE_MTEXT",SWIG_From_int((int)(LEADER_ANNOTTYPE_MTEXT)));
  SWIG_Python_SetConstant(d, "LEADER_ANNOTTYPE_TOLERANCE",SWIG_From_int((int)(LEADER_ANNOTTYPE_TOLERANCE)));
  SWIG_Python_SetConstant(d, "LEADER_ANNOTTYPE_INSERT",SWIG_From_int((int)(LEADER_ANNOTTYPE_INSERT)));
  SWIG_Python_SetConstant(d, "LEADER_ANNOTTYPE_NO_ANNOT",SWIG_From_int((int)(LEADER_ANNOTTYPE_NO_ANNOT)));
  SWIG_Python_SetConstant(d, "MLINE_FLAGS_HAS_VERTEX",SWIG_From_int((int)(MLINE_FLAGS_HAS_VERTEX)));
  SWIG_Python_SetConstant(d, "MLINE_FLAGS_CLOSED",SWIG_From_int((int)(MLINE_FLAGS_CLOSED)));
  SWIG_Python_SetConstant(d, "MLINE_FLAGS_SUPPRESS_START_CAPS",SWIG_From_int((int)(MLINE_FLAGS_SUPPRESS_START_CAPS)));
  SWIG_Python_SetConstant(d, "MLINE_FLAGS_SUPPRESS_END_CAPS",SWIG_From_int((int)(MLINE_FLAGS_SUPPRESS_END_CAPS)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_FILL",SWIG_From_int((int)(MLINESTYLE_FLAG_FILL)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_MITERS",SWIG_From_int((int)(MLINESTYLE_FLAG_MITERS)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_UNKNOWN_4",SWIG_From_int((int)(MLINESTYLE_FLAG_UNKNOWN_4)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_UNKNOWN_8",SWIG_From_int((int)(MLINESTYLE_FLAG_UNKNOWN_8)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_START_SQUARE_END",SWIG_From_int((int)(MLINESTYLE_FLAG_START_SQUARE_END)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_START_INNER_ARC",SWIG_From_int((int)(MLINESTYLE_FLAG_START_INNER_ARC)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_START_ROUND",SWIG_From_int((int)(MLINESTYLE_FLAG_START_ROUND)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_UNKNOWN_128",SWIG_From_int((int)(MLINESTYLE_FLAG_UNKNOWN_128)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_END_SQUARE",SWIG_From_int((int)(MLINESTYLE_FLAG_END_SQUARE)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_END_INNER_ARC",SWIG_From_int((int)(MLINESTYLE_FLAG_END_INNER_ARC)));
  SWIG_Python_SetConstant(d, "MLINESTYLE_FLAG_END_ROUND",SWIG_From_int((int)(MLINESTYLE_FLAG_END_ROUND)));
  SWIG_Python_SetConstant(d, "LIGHT_TYPE_DISTANT",SWIG_From_int((int)(LIGHT_TYPE_DISTANT)));
  SWIG_Python_SetConstant(d, "LIGHT_TYPE_POINT",SWIG_From_int((int)(LIGHT_TYPE_POINT)));
  SWIG_Python_SetConstant(d, "LIGHT_TYPE_SPOT",SWIG_From_int((int)(LIGHT_TYPE_SPOT)));
  SWIG_Python_SetConstant(d, "LIGHT_ATTENUATION_TYPE_NONE",SWIG_From_int((int)(LIGHT_ATTENUATION_TYPE_NONE)));
  SWIG_Python_SetConstant(d, "LIGHT_ATTENUATION_TYPE_INV_LINEAR",SWIG_From_int((int)(LIGHT_ATTENUATION_TYPE_INV_LINEAR)));
  SWIG_Python_SetConstant(d, "LIGHT_ATTENUATION_TYPE_INV_SQUARE",SWIG_From_int((int)(LIGHT_ATTENUATION_TYPE_INV_SQUARE)));
  SWIG_Python_SetConstant(d, "LIGHT_EXTLIGHT_SHAPE_LINEAR",SWIG_From_int((int)(LIGHT_EXTLIGHT_SHAPE_LINEAR)));
  SWIG_Python_SetConstant(d, "LIGHT_EXTLIGHT_SHAPE_RECT",SWIG_From_int((int)(LIGHT_EXTLIGHT_SHAPE_RECT)));
  SWIG_Python_SetConstant(d, "LIGHT_EXTLIGHT_SHAPE_DISK",SWIG_From_int((int)(LIGHT_EXTLIGHT_SHAPE_DISK)));
  SWIG_Python_SetConstant(d, "LIGHT_EXTLIGHT_SHAPE_CYLINDER",SWIG_From_int((int)(LIGHT_EXTLIGHT_SHAPE_CYLINDER)));
  SWIG_Python_SetConstant(d, "LIGHT_EXTLIGHT_SHAPE_SPHERE",SWIG_From_int((int)(LIGHT_EXTLIGHT_SHAPE_SPHERE)));
  SWIG_Python_SetConstant(d, "_3DFACE_INVISIBLE_EDGE1",SWIG_From_int((int)(_3DFACE_INVISIBLE_EDGE1)));
  SWIG_Python_SetConstant(d, "_3DFACE_INVISIBLE_EDGE2",SWIG_From_int((int)(_3DFACE_INVISIBLE_EDGE2)));
  SWIG_Python_SetConstant(d, "_3DFACE_INVISIBLE_EDGE3",SWIG_From_int((int)(_3DFACE_INVISIBLE_EDGE3)));
  SWIG_Python_SetConstant(d, "_3DFACE_INVISIBLE_EDGE4",SWIG_From_int((int)(_3DFACE_INVISIBLE_EDGE4)));
  SWIG_Python_SetConstant(d, "SECTION_UNKNOWN",SWIG_From_int((int)(SECTION_UNKNOWN)));
  SWIG_Python_SetConstant(d, "SECTION_HEADER",SWIG_From_int((int)(SECTION_HEADER)));
  SWIG_Python_SetConstant(d, "SECTION_AUXHEADER",SWIG_From_int((int)(SECTION_AUXHEADER)));
  SWIG_Python_SetConstant(d, "SECTION_CLASSES",SWIG_From_int((int)(SECTION_CLASSES)));
  SWIG_Python_SetConstant(d, "SECTION_HANDLES",SWIG_From_int((int)(SECTION_HANDLES)));
  SWIG_Python_SetConstant(d, "SECTION_TEMPLATE",SWIG_From_int((int)(SECTION_TEMPLATE)));
  SWIG_Python_SetConstant(d, "SECTION_OBJFREESPACE",SWIG_From_int((int)(SECTION_OBJFREESPACE)));
  SWIG_Python_SetConstant(d, "SECTION_OBJECTS",SWIG_From_int((int)(SECTION_OBJECTS)));
  SWIG_Python_SetConstant(d, "SECTION_REVHISTORY",SWIG_From_int((int)(SECTION_REVHISTORY)));
  SWIG_Python_SetConstant(d, "SECTION_SUMMARYINFO",SWIG_From_int((int)(SECTION_SUMMARYINFO)));
  SWIG_Python_SetConstant(d, "SECTION_PREVIEW",SWIG_From_int((int)(SECTION_PREVIEW)));
  SWIG_Python_SetConstant(d, "SECTION_APPINFO",SWIG_From_int((int)(SECTION_APPINFO)));
  SWIG_Python_SetConstant(d, "SECTION_APPINFOHISTORY",SWIG_From_int((int)(SECTION_APPINFOHISTORY)));
  SWIG_Python_SetConstant(d, "SECTION_FILEDEPLIST",SWIG_From_int((int)(SECTION_FILEDEPLIST)));
  SWIG_Python_SetConstant(d, "SECTION_SECURITY",SWIG_From_int((int)(SECTION_SECURITY)));
  SWIG_Python_SetConstant(d, "SECTION_VBAPROJECT",SWIG_From_int((int)(SECTION_VBAPROJECT)));
  SWIG_Python_SetConstant(d, "SECTION_SIGNATURE",SWIG_From_int((int)(SECTION_SIGNATURE)));
  SWIG_Python_SetConstant(d, "SECTION_ACDS",SWIG_From_int((int)(SECTION_ACDS)));
  SWIG_Python_SetConstant(d, "SECTION_INFO",SWIG_From_int((int)(SECTION_INFO)));
  SWIG_Python_SetConstant(d, "SECTION_SYSTEM_MAP",SWIG_From_int((int)(SECTION_SYSTEM_MAP)));
  SWIG_Python_SetConstant(d, "SECTION_HEADER_R13",SWIG_From_int((int)(SECTION_HEADER_R13)));
  SWIG_Python_SetConstant(d, "SECTION_CLASSES_R13",SWIG_From_int((int)(SECTION_CLASSES_R13)));
  SWIG_Python_SetConstant(d, "SECTION_HANDLES_R13",SWIG_From_int((int)(SECTION_HANDLES_R13)));
  SWIG_Python_SetConstant(d, "SECTION_OBJFREESPACE_R13",SWIG_From_int((int)(SECTION_OBJFREESPACE_R13)));
  SWIG_Python_SetConstant(d, "SECTION_TEMPLATE_R13",SWIG_From_int((int)(SECTION_TEMPLATE_R13)));
  SWIG_Python_SetConstant(d, "SECTION_AUXHEADER_R2000",SWIG_From_int((int)(SECTION_AUXHEADER_R2000)));
  SWIG_Python_SetConstant(d, "SECTION_THUMBNAIL_R13",SWIG_From_int((int)(SECTION_THUMBNAIL_R13)));
  SWIG_Python_SetConstant(d, "SECTION_HEADER_R11",SWIG_From_int((int)(SECTION_HEADER_R11)));
  SWIG_Python_SetConstant(d, "SECTION_BLOCK",SWIG_From_int((int)(SECTION_BLOCK)));
  SWIG_Python_SetConstant(d, "SECTION_LAYER",SWIG_From_int((int)(SECTION_LAYER)));
  SWIG_Python_SetConstant(d, "SECTION_STYLE",SWIG_From_int((int)(SECTION_STYLE)));
  SWIG_Python_SetConstant(d, "SECTION_LTYPE",SWIG_From_int((int)(SECTION_LTYPE)));
  SWIG_Python_SetConstant(d, "SECTION_VIEW",SWIG_From_int((int)(SECTION_VIEW)));
  SWIG_Python_SetConstant(d, "SECTION_UCS",SWIG_From_int((int)(SECTION_UCS)));
  SWIG_Python_SetConstant(d, "SECTION_VPORT",SWIG_From_int((int)(SECTION_VPORT)));
  SWIG_Python_SetConstant(d, "SECTION_APPID",SWIG_From_int((int)(SECTION_APPID)));
  SWIG_Python_SetConstant(d, "SECTION_DIMSTYLE",SWIG_From_int((int)(SECTION_DIMSTYLE)));
  SWIG_Python_SetConstant(d, "SECTION_VX",SWIG_From_int((int)(SECTION_VX)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_LOGLEVEL",SWIG_From_int((int)(0xf)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_MINIMAL",SWIG_From_int((int)(0x10)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_DXFB",SWIG_From_int((int)(0x20)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_JSONFIRST",SWIG_From_int((int)(0x20)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_INDXF",SWIG_From_int((int)(0x40)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_INJSON",SWIG_From_int((int)(0x80)));
  SWIG_Python_SetConstant(d, "DWG_OPTS_IN",SWIG_From_int((int)((0x40|0x80))));
  SWIG_Python_SetConstant(d, "DWG_VT_INVALID",SWIG_From_int((int)(DWG_VT_INVALID)));
  SWIG_Python_SetConstant(d, "DWG_VT_STRING",SWIG_From_int((int)(DWG_VT_STRING)));
  SWIG_Python_SetConstant(d, "DWG_VT_POINT3D",SWIG_From_int((int)(DWG_VT_POINT3D)));
  SWIG_Python_SetConstant(d, "DWG_VT_REAL",SWIG_From_int((int)(DWG_VT_REAL)));
  SWIG_Python_SetConstant(d, "DWG_VT_INT16",SWIG_From_int((int)(DWG_VT_INT16)));
  SWIG_Python_SetConstant(d, "DWG_VT_INT32",SWIG_From_int((int)(DWG_VT_INT32)));
  SWIG_Python_SetConstant(d, "DWG_VT_INT8",SWIG_From_int((int)(DWG_VT_INT8)));
  SWIG_Python_SetConstant(d, "DWG_VT_BINARY",SWIG_From_int((int)(DWG_VT_BINARY)));
  SWIG_Python_SetConstant(d, "DWG_VT_HANDLE",SWIG_From_int((int)(DWG_VT_HANDLE)));
  SWIG_Python_SetConstant(d, "DWG_VT_OBJECTID",SWIG_From_int((int)(DWG_VT_OBJECTID)));
  SWIG_Python_SetConstant(d, "DWG_VT_BOOL",SWIG_From_int((int)(DWG_VT_BOOL)));
  SWIG_Python_SetConstant(d, "DWG_VT_INT64",SWIG_From_int((int)(DWG_VT_INT64)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

